From ff04a5678cc1b72bfb5eb9269c80889d36e7ad04 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Wed, 19 Dec 2018 16:39:04 +0000
Subject: [PATCH 001/137] Add missing include to test. NFC

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349639 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp         | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
index 76ac99165..ac3b95fbe 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
@@ -16,6 +16,7 @@
 //   find_end(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred);
 
 #include <algorithm>
+#include <functional>
 #include <cassert>
 
 #include "test_macros.h"
-- 
GitLab


From 1e048a3c695f166840af3e57b84e868e7e2f3d88 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 19 Dec 2018 18:58:22 +0000
Subject: [PATCH 002/137] Work around GCC 9.0 regression

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349663 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../utilities/variant/variant.variant/variant_size.pass.cpp    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
index a836ef516..c309aaaae 100644
--- a/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
+++ b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
@@ -24,7 +24,8 @@ struct make_variant_imp;
 
 template <size_t ...Indices>
 struct make_variant_imp<std::integer_sequence<size_t, Indices...>> {
-  using type = std::variant<decltype((Indices, char(0)))...>;
+  template <size_t> using AlwaysChar = char;
+  using type = std::variant<AlwaysChar<Indices>...>;
 };
 
 template <size_t N>
-- 
GitLab


From d805c8746ac1b5c8f5f9d69a88a57b4d46763a76 Mon Sep 17 00:00:00 2001
From: Volodymyr Sapsai <vsapsai@apple.com>
Date: Wed, 19 Dec 2018 20:08:43 +0000
Subject: [PATCH 003/137] [libcxx] Use custom allocator's `construct` in C++03
 when available.

Makes libc++ behavior consistent between C++03 and C++11.

Can use `decltype` in C++03 because `include/__config` defines a macro when
`decltype` is not available.

Reviewers: mclow.lists, EricWF, erik.pilkington, ldionne

Reviewed By: ldionne

Subscribers: dexonsmith, cfe-commits, howard.hinnant, ldionne, christof, jkorous, Quuxplusone

Differential Revision: https://reviews.llvm.org/D48753


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349676 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/memory                                | 48 +++++++++-------
 .../vector.cons/construct_iter_iter.pass.cpp  | 54 ++++++++++++++++++
 .../construct_iter_iter_alloc.pass.cpp        | 57 +++++++++++++++++++
 .../allocator.traits.members/destroy.pass.cpp |  2 +-
 test/support/min_allocator.h                  | 54 ++++++++++++++++++
 5 files changed, 193 insertions(+), 22 deletions(-)
 create mode 100644 test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
 create mode 100644 test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

diff --git a/include/memory b/include/memory
index 3e8f5936e..b012f5bce 100644
--- a/include/memory
+++ b/include/memory
@@ -1460,29 +1460,21 @@ struct __has_select_on_container_copy_construction
 
 #else  // _LIBCPP_CXX03_LANG
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
-template <class _Alloc, class _Pointer, class ..._Args>
-struct __has_construct
-    : false_type
-{
-};
+template <class _Alloc, class _Pointer, class _Tp, class = void>
+struct __has_construct : std::false_type {};
 
-#else  // _LIBCPP_HAS_NO_VARIADICS
+template <class _Alloc, class _Pointer, class _Tp>
+struct __has_construct<_Alloc, _Pointer, _Tp, typename __void_t<
+    decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Pointer>(), _VSTD::declval<_Tp>()))
+>::type> : std::true_type {};
 
-template <class _Alloc, class _Pointer, class _Args>
-struct __has_construct
-    : false_type
-{
-};
-
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+template <class _Alloc, class _Pointer, class = void>
+struct __has_destroy : false_type {};
 
 template <class _Alloc, class _Pointer>
-struct __has_destroy
-    : false_type
-{
-};
+struct __has_destroy<_Alloc, _Pointer, typename __void_t<
+    decltype(_VSTD::declval<_Alloc>().destroy(_VSTD::declval<_Pointer>()))
+>::type> : std::true_type {};
 
 template <class _Alloc>
 struct __has_max_size
@@ -1571,9 +1563,10 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
             }
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
-        static void construct(allocator_type&, _Tp* __p, const _A0& __a0)
+        static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0)
             {
-                ::new ((void*)__p) _Tp(__a0);
+                __construct(__has_construct<allocator_type, _Tp*, const _A0&>(),
+                            __a, __p, __a0);
             }
     template <class _Tp, class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
@@ -1721,6 +1714,19 @@ private:
             {
                 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
             }
+#else  // _LIBCPP_HAS_NO_VARIADICS
+    template <class _Tp, class _A0>
+        _LIBCPP_INLINE_VISIBILITY
+        static void __construct(true_type, allocator_type& __a, _Tp* __p,
+                                const _A0& __a0)
+            {__a.construct(__p, __a0);}
+    template <class _Tp, class _A0>
+        _LIBCPP_INLINE_VISIBILITY
+        static void __construct(false_type, allocator_type&, _Tp* __p,
+                                const _A0& __a0)
+            {
+                ::new ((void*)__p) _Tp(__a0);
+            }
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _Tp>
diff --git a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
new file mode 100644
index 000000000..998d0b74e
--- /dev/null
+++ b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// template <class InputIter> vector(InputIter first, InputIter last);
+
+#include <vector>
+#include <cassert>
+
+#include "min_allocator.h"
+
+void test_ctor_under_alloc() {
+  int arr1[] = {42};
+  int arr2[] = {1, 101, 42};
+  {
+    typedef std::vector<int, cpp03_allocator<int> > C;
+    typedef C::allocator_type Alloc;
+    {
+      Alloc::construct_called = false;
+      C v(arr1, arr1 + 1);
+      assert(Alloc::construct_called);
+    }
+    {
+      Alloc::construct_called = false;
+      C v(arr2, arr2 + 3);
+      assert(Alloc::construct_called);
+    }
+  }
+  {
+    typedef std::vector<int, cpp03_overload_allocator<int> > C;
+    typedef C::allocator_type Alloc;
+    {
+      Alloc::construct_called = false;
+      C v(arr1, arr1 + 1);
+      assert(Alloc::construct_called);
+    }
+    {
+      Alloc::construct_called = false;
+      C v(arr2, arr2 + 3);
+      assert(Alloc::construct_called);
+    }
+  }
+}
+
+int main() {
+  test_ctor_under_alloc();
+}
diff --git a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
new file mode 100644
index 000000000..c4950fbe6
--- /dev/null
+++ b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// template <class InputIter> vector(InputIter first, InputIter last,
+//                                   const allocator_type& a);
+
+#include <vector>
+#include <cassert>
+
+#include "min_allocator.h"
+
+void test_ctor_under_alloc() {
+  int arr1[] = {42};
+  int arr2[] = {1, 101, 42};
+  {
+    typedef std::vector<int, cpp03_allocator<int> > C;
+    typedef C::allocator_type Alloc;
+    Alloc a;
+    {
+      Alloc::construct_called = false;
+      C v(arr1, arr1 + 1, a);
+      assert(Alloc::construct_called);
+    }
+    {
+      Alloc::construct_called = false;
+      C v(arr2, arr2 + 3, a);
+      assert(Alloc::construct_called);
+    }
+  }
+  {
+    typedef std::vector<int, cpp03_overload_allocator<int> > C;
+    typedef C::allocator_type Alloc;
+    Alloc a;
+    {
+      Alloc::construct_called = false;
+      C v(arr1, arr1 + 1, a);
+      assert(Alloc::construct_called);
+    }
+    {
+      Alloc::construct_called = false;
+      C v(arr2, arr2 + 3, a);
+      assert(Alloc::construct_called);
+    }
+  }
+}
+
+int main() {
+  test_ctor_under_alloc();
+}
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
index 1a812876b..1060b7343 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
@@ -73,7 +73,7 @@ int main()
       std::aligned_storage<sizeof(VT)>::type store;
       std::allocator_traits<Alloc>::destroy(a, (VT*)&store);
     }
-#if TEST_STD_VER >= 11
+#if defined(_LIBCPP_VERSION) || TEST_STD_VER >= 11
     {
         A0::count = 0;
         b_destroy = 0;
diff --git a/test/support/min_allocator.h b/test/support/min_allocator.h
index a3af9e1db..454749397 100644
--- a/test/support/min_allocator.h
+++ b/test/support/min_allocator.h
@@ -14,6 +14,7 @@
 #include <cstdlib>
 #include <cstddef>
 #include <cassert>
+#include <climits>
 
 #include "test_macros.h"
 
@@ -131,6 +132,59 @@ public:
     friend bool operator!=(malloc_allocator x, malloc_allocator y) {return !(x == y);}
 };
 
+template <class T>
+struct cpp03_allocator : bare_allocator<T>
+{
+    typedef T value_type;
+    typedef value_type* pointer;
+
+    static bool construct_called;
+
+    // Returned value is not used but it's not prohibited.
+    pointer construct(pointer p, const value_type& val)
+    {
+        ::new(p) value_type(val);
+        construct_called = true;
+        return p;
+    }
+
+    std::size_t max_size() const
+    {
+        return UINT_MAX / sizeof(T);
+    }
+};
+template <class T> bool cpp03_allocator<T>::construct_called = false;
+
+template <class T>
+struct cpp03_overload_allocator : bare_allocator<T>
+{
+    typedef T value_type;
+    typedef value_type* pointer;
+
+    static bool construct_called;
+
+    void construct(pointer p, const value_type& val)
+    {
+        construct(p, val, std::is_class<T>());
+    }
+    void construct(pointer p, const value_type& val, std::true_type)
+    {
+        ::new(p) value_type(val);
+        construct_called = true;
+    }
+    void construct(pointer p, const value_type& val, std::false_type)
+    {
+        ::new(p) value_type(val);
+        construct_called = true;
+    }
+
+    std::size_t max_size() const
+    {
+        return UINT_MAX / sizeof(T);
+    }
+};
+template <class T> bool cpp03_overload_allocator<T>::construct_called = false;
+
 
 #if TEST_STD_VER >= 11
 
-- 
GitLab


From 8daffdabc50c469f08cfe06fbd075044f6466e37 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Thu, 20 Dec 2018 17:55:31 +0000
Subject: [PATCH 004/137] [libcxx] Fix order checking in unordered_multimap
 tests.

Some tests assume that iteration through an unordered multimap elements
will return them in the same order as at the container creation. This
assumption is not true since the container is unordered, so that no
specific order of elements is ever guaranteed for such container. This
patch introduces checks verifying that any iteration will return elements
exactly from a set of valid values and without repetition, but in no
particular order.

Reviewed as https://reviews.llvm.org/D54838.
Thanks to Andrey Maksimov for the patch.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349780 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../unord.multimap/equal_range_const.pass.cpp |  39 ++-
 .../equal_range_non_const.pass.cpp            |  39 ++-
 .../unord.multimap/local_iterators.pass.cpp   | 273 +++++++++++++-----
 .../unord/unord.multimap/rehash.pass.cpp      |  36 ++-
 .../unord/unord.multimap/reserve.pass.cpp     |  23 +-
 .../unord/unord.multimap/swap_member.pass.cpp | 121 ++++++--
 6 files changed, 379 insertions(+), 152 deletions(-)

diff --git a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
index 382ed7c98..65c9f8c12 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "min_allocator.h"
@@ -48,14 +49,17 @@ int main()
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
-        assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
+            assert(r.first->first == 50);
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
+            ++r.first;
+        }
     }
 #if TEST_STD_VER >= 11
     {
@@ -84,14 +88,17 @@ int main()
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
-        assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
+            assert(r.first->first == 50);
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
+            ++r.first;
+        }
     }
 #endif
 }
diff --git a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
index 17eb14e44..10fafee80 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "min_allocator.h"
@@ -48,14 +49,17 @@ int main()
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
-        assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
+            assert(r.first->first == 50);
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
+            ++r.first;
+        }
     }
 #if TEST_STD_VER >= 11
     {
@@ -84,14 +88,17 @@ int main()
         r = c.equal_range(5);
         assert(std::distance(r.first, r.second) == 0);
         r = c.equal_range(50);
-        assert(r.first->first == 50);
-        assert(r.first->second == "fifty");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyA");
-        ++r.first;
-        assert(r.first->first == 50);
-        assert(r.first->second == "fiftyB");
+        std::set<std::string> s;
+        s.insert("fifty");
+        s.insert("fiftyA");
+        s.insert("fiftyB");
+        for ( int i = 0; i < 3; ++i )
+        {
+            assert(r.first->first == 50);
+            assert(s.find(r.first->second) != s.end());
+            s.erase(s.find(r.first->second));
+            ++r.first;
+        }
     }
 #endif
 }
diff --git a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
index 504fe54de..2976d2c3c 100644
--- a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
@@ -22,6 +22,7 @@
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "min_allocator.h"
@@ -52,21 +53,35 @@ int main()
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
@@ -116,21 +131,35 @@ int main()
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
@@ -180,21 +209,35 @@ int main()
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
@@ -244,21 +287,35 @@ int main()
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
@@ -310,21 +367,35 @@ int main()
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
@@ -375,21 +446,35 @@ int main()
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.begin(b);
         j = c.end(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.begin(b);
@@ -440,21 +525,35 @@ int main()
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
@@ -505,21 +604,35 @@ int main()
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 1);
-        assert(i->second == "one");
-        ++i;
-        assert(i->first == 1);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 1);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(2);
         i = c.cbegin(b);
         j = c.cend(b);
         assert(std::distance(i, j) == 2);
-        assert(i->first == 2);
-        assert(i->second == "two");
-        ++i;
-        assert(i->first == 2);
-        assert(i->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            for ( int n = 0; n < 2; ++n )
+            {
+                assert(i->first == 2);
+                assert(s.find(i->second) != s.end());
+                s.erase(s.find(i->second));
+                ++i;
+            }
+        }
 
         b = c.bucket(3);
         i = c.cbegin(b);
diff --git a/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index 22202ccb6..e8394d7f7 100644
--- a/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
@@ -39,20 +40,33 @@ void test(const C& c)
     Eq eq = c.equal_range(1);
     assert(std::distance(eq.first, eq.second) == 2);
     typename C::const_iterator i = eq.first;
-    assert(i->first == 1);
-    assert(i->second == "one");
-    ++i;
-    assert(i->first == 1);
-    assert(i->second == "four");
+    {
+        std::set<std::string> s;
+        s.insert("one");
+        s.insert("four");
+        for ( int n = 0; n < 2; ++n )
+        {
+            assert(i->first == 1);
+            assert(s.find(i->second) != s.end());
+            s.erase(s.find(i->second));
+            ++i;
+        }
+    }
     eq = c.equal_range(2);
     assert(std::distance(eq.first, eq.second) == 2);
     i = eq.first;
-    assert(i->first == 2);
-    assert(i->second == "two");
-    ++i;
-    assert(i->first == 2);
-    assert(i->second == "four");
-
+    {
+        std::set<std::string> s;
+        s.insert("two");
+        s.insert("four");
+        for ( int n = 0; n < 2; ++n )
+        {
+            assert(i->first == 2);
+            assert(s.find(i->second) != s.end());
+            s.erase(s.find(i->second));
+            ++i;
+        }
+    }
     eq = c.equal_range(3);
     assert(std::distance(eq.first, eq.second) == 1);
     i = eq.first;
diff --git a/test/std/containers/unord/unord.multimap/reserve.pass.cpp b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
index d86c69c88..003337774 100644
--- a/test/std/containers/unord/unord.multimap/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
@@ -13,10 +13,11 @@
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
-// void rehash(size_type n);
+// void reserve(size_type n);
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 
 #include "test_macros.h"
@@ -26,10 +27,22 @@ template <class C>
 void test(const C& c)
 {
     assert(c.size() == 6);
-    assert(c.find(1)->second == "one");
-    assert(next(c.find(1))->second == "four");
-    assert(c.find(2)->second == "two");
-    assert(next(c.find(2))->second == "four");
+    {
+        std::set<std::string> s;
+        s.insert("one");
+        s.insert("four");
+        assert(s.find(c.find(1)->second) != s.end());
+        s.erase(s.find(c.find(1)->second));
+        assert(s.find(next(c.find(1))->second) != s.end());
+    }
+    {
+        std::set<std::string> s;
+        s.insert("two");
+        s.insert("four");
+        assert(s.find(c.find(2)->second) != s.end());
+        s.erase(s.find(c.find(2)->second));
+        assert(s.find(next(c.find(2))->second) != s.end());
+    }
     assert(c.find(3)->second == "three");
     assert(c.find(4)->second == "four");
 }
diff --git a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
index 8c5ddab05..3f0259794 100644
--- a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_map>
 #include <string>
+#include <set>
 #include <cassert>
 #include <cstddef>
 
@@ -136,10 +137,22 @@ int main()
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
@@ -199,10 +212,22 @@ int main()
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
@@ -320,10 +345,22 @@ int main()
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
@@ -383,10 +420,22 @@ int main()
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
@@ -504,10 +553,22 @@ int main()
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
@@ -567,10 +628,22 @@ int main()
 
         assert(c2.bucket_count() >= 6);
         assert(c2.size() == 6);
-        assert(c2.find(1)->second == "one");
-        assert(next(c2.find(1))->second == "four");
-        assert(c2.find(2)->second == "two");
-        assert(next(c2.find(2))->second == "four");
+        {
+            std::set<std::string> s;
+            s.insert("one");
+            s.insert("four");
+            assert(s.find(c2.find(1)->second) != s.end());
+            s.erase(s.find(c2.find(1)->second));
+            assert(s.find(next(c2.find(1))->second) != s.end());
+        }
+        {
+            std::set<std::string> s;
+            s.insert("two");
+            s.insert("four");
+            assert(s.find(c2.find(2)->second) != s.end());
+            s.erase(s.find(c2.find(2)->second));
+            assert(s.find(next(c2.find(2))->second) != s.end());
+        }
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
-- 
GitLab


From 545d0b950d2cdcfcdbb5e02f68cae72c079b619d Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 02:17:00 +0000
Subject: [PATCH 005/137] Mark two filesystem LWG issues as complete - nothing
 to do

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349877 91177308-0d34-0410-b5e6-96231b3b80d8
---
 www/cxx2a_status.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index 581191c76..f8a5a831f 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -255,11 +255,11 @@
 	<tr><td><a href="https://wg21.link/LWG2184">2184</a></td><td>Muddled allocator requirements for <tt>match_results</tt> assignments</td><td>San Diego</td><td>Complete</td></tr>
 	<tr><td><a href="https://wg21.link/LWG2412">2412</a></td><td><tt>promise::set_value()</tt> and <tt>promise::get_future()</tt> should not race</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG2499">2499</a></td><td><tt>operator&gt;&gt;(basic_istream&amp;, CharT*)</tt> makes it hard to avoid buffer overflows</td><td>San Diego</td><td>Resolved by P0487R1</td></tr>
-	<tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td><code>filesystem::copy()</code> won't create a symlink to a directory</td><td>San Diego</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td><code>filesystem::copy()</code> won't create a symlink to a directory</td><td>San Diego</td><td>Nothing to do</td></tr>
 	<tr><td><a href="https://wg21.link/LWG2697">2697</a></td><td>[concurr.ts] Behavior of <tt>future/shared_future</tt> unwrapping constructor when given an invalid <tt>future</tt></td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG2797">2797</a></td><td>Trait precondition violations</td><td>San Diego</td><td>Resolved by 1285R0</td></tr>
 	<tr><td><a href="https://wg21.link/LWG2936">2936</a></td><td>Path comparison is defined in terms of the generic format</td><td>San Diego</td><td></td></tr>
-	<tr><td><a href="https://wg21.link/LWG2943">2943</a></td><td>Problematic specification of the wide version of <tt>basic_filebuf::open</tt></td><td>San Diego</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2943">2943</a></td><td>Problematic specification of the wide version of <tt>basic_filebuf::open</tt></td><td>San Diego</td><td>Nothing to do</td></tr>
 	<tr><td><a href="https://wg21.link/LWG2960">2960</a></td><td>[fund.ts.v3] <tt>nonesuch</tt> is insufficiently useless</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG2995">2995</a></td><td><tt>basic_stringbuf</tt> default constructor forbids it from using SSO capacity</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG2996">2996</a></td><td>Missing rvalue overloads for <tt>shared_ptr</tt> operations</td><td>San Diego</td><td></td></tr>
-- 
GitLab


From a2037284d41905968965638957ea29f9a7e3220e Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 03:16:30 +0000
Subject: [PATCH 006/137] Implement LWG 2936: Path comparison is defined in
 terms of the generic format

This patch implements path::compare according to the current spec. The
only observable change is the ordering of "/foo" and "foo", which orders
the two paths based on having or not having a root directory (instead
of lexically comparing "/" to "foo").

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349881 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/filesystem/operations.cpp                 | 97 ++++++++++++++++---
 .../path.member/path.compare.pass.cpp         | 55 ++++++++++-
 www/cxx2a_status.html                         |  2 +-
 3 files changed, 139 insertions(+), 15 deletions(-)

diff --git a/src/filesystem/operations.cpp b/src/filesystem/operations.cpp
index c9396b59c..0b79ef1cd 100644
--- a/src/filesystem/operations.cpp
+++ b/src/filesystem/operations.cpp
@@ -206,8 +206,20 @@ public:
     return *this;
   }
 
+  bool atEnd() const noexcept {
+    return State == PS_AtEnd;
+  }
+
+  bool inRootDir() const noexcept {
+    return State == PS_InRootDir;
+  }
+
+  bool inRootName() const noexcept {
+    return State == PS_InRootName;
+  }
+
   bool inRootPath() const noexcept {
-    return State == PS_InRootDir || State == PS_InRootName;
+    return inRootName() || inRootDir();
   }
 
 private:
@@ -1294,7 +1306,19 @@ string_view_t path::__root_path_raw() const {
   return {};
 }
 
+static bool ConsumeRootName(PathParser *PP) {
+  static_assert(PathParser::PS_BeforeBegin == 1 &&
+      PathParser::PS_InRootName == 2,
+      "Values for enums are incorrect");
+  while (PP->State <= PathParser::PS_InRootName)
+    ++(*PP);
+  return PP->State == PathParser::PS_AtEnd;
+}
+
 static bool ConsumeRootDir(PathParser* PP) {
+  static_assert(PathParser::PS_BeforeBegin == 1 &&
+                PathParser::PS_InRootName == 2 &&
+                PathParser::PS_InRootDir == 3, "Values for enums are incorrect");
   while (PP->State <= PathParser::PS_InRootDir)
     ++(*PP);
   return PP->State == PathParser::PS_AtEnd;
@@ -1514,21 +1538,68 @@ path path::lexically_relative(const path& base) const {
 
 ////////////////////////////////////////////////////////////////////////////
 // path.comparisons
-int path::__compare(string_view_t __s) const {
-  auto PP = PathParser::CreateBegin(__pn_);
-  auto PP2 = PathParser::CreateBegin(__s);
-  while (PP && PP2) {
-    int res = (*PP).compare(*PP2);
-    if (res != 0)
+static int CompareRootName(PathParser *LHS, PathParser *RHS) {
+  if (!LHS->inRootName() && !RHS->inRootName())
+    return 0;
+
+  auto GetRootName = [](PathParser *Parser) -> string_view_t {
+    return Parser->inRootName() ? **Parser : "";
+  };
+  int res = GetRootName(LHS).compare(GetRootName(RHS));
+  ConsumeRootName(LHS);
+  ConsumeRootName(RHS);
+  return res;
+}
+
+static int CompareRootDir(PathParser *LHS, PathParser *RHS) {
+  if (!LHS->inRootDir() && RHS->inRootDir())
+    return -1;
+  else if (LHS->inRootDir() && !RHS->inRootDir())
+    return 1;
+  else {
+    ConsumeRootDir(LHS);
+    ConsumeRootDir(RHS);
+    return 0;
+  }
+}
+
+static int CompareRelative(PathParser *LHSPtr, PathParser *RHSPtr) {
+  auto &LHS = *LHSPtr;
+  auto &RHS = *RHSPtr;
+  
+  int res;
+  while (LHS && RHS) {
+    if ((res = (*LHS).compare(*RHS)) != 0)
       return res;
-    ++PP;
-    ++PP2;
+    ++LHS;
+    ++RHS;
   }
-  if (PP.State == PP2.State && !PP)
-    return 0;
-  if (!PP)
+  return 0;
+}
+
+static int CompareEndState(PathParser *LHS, PathParser *RHS) {
+  if (LHS->atEnd() && !RHS->atEnd())
     return -1;
-  return 1;
+  else if (!LHS->atEnd() && RHS->atEnd())
+    return 1;
+  return 0;
+}
+
+int path::__compare(string_view_t __s) const {
+  auto LHS = PathParser::CreateBegin(__pn_);
+  auto RHS = PathParser::CreateBegin(__s);
+  int res;
+
+  if ((res = CompareRootName(&LHS, &RHS)) != 0)
+    return res;
+
+  if ((res = CompareRootDir(&LHS, &RHS)) != 0)
+    return res;
+
+  if ((res = CompareRelative(&LHS, &RHS)) != 0)
+    return res;
+
+  return CompareEndState(&LHS, &RHS);
 }
 
 ////////////////////////////////////////////////////////////////////////////
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
index 7791097dc..2be6122a0 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
@@ -65,6 +65,8 @@ const PathCompareTest CompareTestCases[] =
     {"//foo//bar///baz////", "//foo/bar/baz/", 0}, // duplicate separators
     {"///foo/bar", "/foo/bar", 0}, // "///" is not a root directory
     {"/foo/bar/", "/foo/bar", 1}, // trailing separator
+    {"foo", "/foo", -1}, // if !this->has_root_directory() and p.has_root_directory(), a value less than 0.
+    {"/foo", "foo", 1}, //  if this->has_root_directory() and !p.has_root_directory(), a value greater than 0.
     {"//" LONGA "////" LONGB "/" LONGC "///" LONGD, "//" LONGA "/" LONGB "/" LONGC "/" LONGD, 0},
     { LONGA "/" LONGB "/" LONGC, LONGA "/" LONGB "/" LONGB, 1}
 
@@ -79,7 +81,7 @@ static inline int normalize_ret(int ret)
   return ret < 0 ? -1 : (ret > 0 ? 1 : 0);
 }
 
-int main()
+void test_compare_basic()
 {
   using namespace fs;
   for (auto const & TC : CompareTestCases) {
@@ -136,3 +138,54 @@ int main()
     }
   }
 }
+
+int CompareElements(std::vector<std::string> const& LHS, std::vector<std::string> const& RHS) {
+  bool IsLess = std::lexicographical_compare(LHS.begin(), LHS.end(), RHS.begin(), RHS.end());
+  if (IsLess)
+    return -1;
+
+  bool IsGreater = std::lexicographical_compare(RHS.begin(), RHS.end(), LHS.begin(), LHS.end());
+  if (IsGreater)
+    return 1;
+
+  return 0;
+}
+
+void test_compare_elements() {
+  struct {
+    std::vector<std::string> LHSElements;
+    std::vector<std::string> RHSElements;
+    int Expect;
+  } TestCases[] = {
+      {{"a"}, {"a"}, 0},
+      {{"a"}, {"b"}, -1},
+      {{"b"}, {"a"}, 1},
+      {{"a", "b", "c"}, {"a", "b", "c"}, 0},
+      {{"a", "b", "c"}, {"a", "b", "d"}, -1},
+      {{"a", "b", "d"}, {"a", "b", "c"}, 1},
+      {{"a", "b"}, {"a", "b", "c"}, -1},
+      {{"a", "b", "c"}, {"a", "b"}, 1},
+
+  };
+
+  auto BuildPath = [](std::vector<std::string> const& Elems) {
+    fs::path p;
+    for (auto &E : Elems)
+      p /= E;
+    return p;
+  };
+
+  for (auto &TC : TestCases) {
+    fs::path LHS = BuildPath(TC.LHSElements);
+    fs::path RHS = BuildPath(TC.RHSElements);
+    const int ExpectCmp = CompareElements(TC.LHSElements, TC.RHSElements);
+    assert(ExpectCmp == TC.Expect);
+    const int GotCmp = normalize_ret(LHS.compare(RHS));
+    assert(GotCmp == TC.Expect);
+  }
+}
+
+int main() {
+  test_compare_basic();
+  test_compare_elements();
+}
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index f8a5a831f..25e6cdfe4 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -258,7 +258,7 @@
 	<tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td><code>filesystem::copy()</code> won't create a symlink to a directory</td><td>San Diego</td><td>Nothing to do</td></tr>
 	<tr><td><a href="https://wg21.link/LWG2697">2697</a></td><td>[concurr.ts] Behavior of <tt>future/shared_future</tt> unwrapping constructor when given an invalid <tt>future</tt></td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG2797">2797</a></td><td>Trait precondition violations</td><td>San Diego</td><td>Resolved by 1285R0</td></tr>
-	<tr><td><a href="https://wg21.link/LWG2936">2936</a></td><td>Path comparison is defined in terms of the generic format</td><td>San Diego</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2936">2936</a></td><td>Path comparison is defined in terms of the generic format</td><td>San Diego</td><td>Complete</td></tr>
 	<tr><td><a href="https://wg21.link/LWG2943">2943</a></td><td>Problematic specification of the wide version of <tt>basic_filebuf::open</tt></td><td>San Diego</td><td>Nothing to do</td></tr>
 	<tr><td><a href="https://wg21.link/LWG2960">2960</a></td><td>[fund.ts.v3] <tt>nonesuch</tt> is insufficiently useless</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG2995">2995</a></td><td><tt>basic_stringbuf</tt> default constructor forbids it from using SSO capacity</td><td>San Diego</td><td></td></tr>
-- 
GitLab


From 874280d14da2949282566327f951d856a2b549d9 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 03:54:57 +0000
Subject: [PATCH 007/137] Implement LWG 3145: file_clock breaks ABI for C++17
 implementations.

This patch adds std::chrono::file_clock, but without breaking the
existing ABI for std::filesystem.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349883 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/chrono                                | 43 ++++++++++++++++++-
 include/filesystem                            | 30 -------------
 .../time.clock.file/consistency.pass.cpp      | 35 +++++++++++++++
 .../time.clock.file/file_time.pass.cpp        | 29 +++++++++++++
 .../time.clock/time.clock.file/now.pass.cpp   | 35 +++++++++++++++
 .../time.clock.file/rep_signed.pass.cpp       | 29 +++++++++++++
 www/cxx2a_status.html                         |  2 +-
 7 files changed, 171 insertions(+), 32 deletions(-)
 create mode 100644 test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
 create mode 100644 test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
 create mode 100644 test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
 create mode 100644 test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp

diff --git a/include/chrono b/include/chrono
index e99e3c74c..a5bb9afa8 100644
--- a/include/chrono
+++ b/include/chrono
@@ -808,6 +808,9 @@ constexpr chrono::year                                  operator ""y(unsigned lo
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+struct _FilesystemClock;
+_LIBCPP_END_NAMESPACE_FILESYSTEM
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -1581,9 +1584,13 @@ typedef system_clock high_resolution_clock;
 #endif
 
 #if _LIBCPP_STD_VER > 17
+// [time.clock.file], type file_clock
+using file_clock = _VSTD_FS::_FilesystemClock;
 
-struct _LIBCPP_TYPE_VIS last_spec { explicit last_spec() = default; };
+template<class _Duration>
+using file_time = time_point<file_clock, _Duration>;
 
+struct _LIBCPP_TYPE_VIS last_spec { explicit last_spec() = default; };
 
 class _LIBCPP_TYPE_VIS day {
 private:
@@ -2689,6 +2696,40 @@ namespace chrono { // hoist the literals into namespace std::chrono
 
 _LIBCPP_END_NAMESPACE_STD
 
+#ifndef _LIBCPP_CXX03_LANG
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+struct _FilesystemClock {
+#if !defined(_LIBCPP_HAS_NO_INT128)
+  typedef __int128_t rep;
+  typedef nano period;
+#else
+  typedef long long rep;
+  typedef nano period;
+#endif
+
+  typedef chrono::duration<rep, period> duration;
+  typedef chrono::time_point<_FilesystemClock> time_point;
+
+  static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
+
+  _LIBCPP_FUNC_VIS static time_point now() noexcept;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static time_t to_time_t(const time_point& __t) noexcept {
+      typedef chrono::duration<rep> __secs;
+      return time_t(
+          chrono::duration_cast<__secs>(__t.time_since_epoch()).count());
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  static time_point from_time_t(time_t __t) noexcept {
+      typedef chrono::duration<rep> __secs;
+      return time_point(__secs(__t));
+  }
+};
+_LIBCPP_END_NAMESPACE_FILESYSTEM
+#endif // !_LIBCPP_CXX03_LANG
+
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_CHRONO
diff --git a/include/filesystem b/include/filesystem
index 339bb252f..06a0eb33c 100644
--- a/include/filesystem
+++ b/include/filesystem
@@ -259,36 +259,6 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-struct _FilesystemClock {
-#if !defined(_LIBCPP_HAS_NO_INT128)
-  typedef __int128_t rep;
-  typedef nano period;
-#else
-  typedef long long rep;
-  typedef nano period;
-#endif
-
-  typedef chrono::duration<rep, period> duration;
-  typedef chrono::time_point<_FilesystemClock> time_point;
-
-  static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
-
-  _LIBCPP_FUNC_VIS static time_point now() noexcept;
-
-  _LIBCPP_INLINE_VISIBILITY
-  static time_t to_time_t(const time_point& __t) noexcept {
-    typedef chrono::duration<rep> __secs;
-    return time_t(
-        chrono::duration_cast<__secs>(__t.time_since_epoch()).count());
-  }
-
-  _LIBCPP_INLINE_VISIBILITY
-  static time_point from_time_t(time_t __t) noexcept {
-    typedef chrono::duration<rep> __secs;
-    return time_point(__secs(__t));
-  }
-};
-
 typedef chrono::time_point<_FilesystemClock> file_time_type;
 
 struct _LIBCPP_TYPE_VIS space_info {
diff --git a/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
new file mode 100644
index 000000000..275faa628
--- /dev/null
+++ b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+//
+// TODO: Remove this when filesystem gets integrated into the dylib
+// REQUIRES: c++filesystem
+
+// <chrono>
+
+// file_clock
+
+// check clock invariants
+
+#include <chrono>
+
+template <class T>
+void test(const T &) {}
+
+int main()
+{
+    typedef std::chrono::system_clock C;
+    static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
+    static_assert((std::is_same<C::period, C::duration::period>::value), "");
+    static_assert((std::is_same<C::duration, C::time_point::duration>::value), "");
+    static_assert((std::is_same<C::time_point::clock, C>::value), "");
+    static_assert((C::is_steady || !C::is_steady), "");
+    test(std::chrono::system_clock::is_steady);
+}
diff --git a/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
new file mode 100644
index 000000000..955e3ebe9
--- /dev/null
+++ b/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+
+// file_time
+
+#include <chrono>
+
+#include "test_macros.h"
+
+template <class Dur>
+void test() {
+  ASSERT_SAME_TYPE(std::chrono::file_time<Dur>, std::chrono::time_point<std::chrono::file_clock, Dur>);
+}
+
+int main() {
+  test<std::chrono::nanoseconds>();
+  test<std::chrono::minutes>();
+  test<std::chrono::hours>();
+}
\ No newline at end of file
diff --git a/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
new file mode 100644
index 000000000..69dfa9180
--- /dev/null
+++ b/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// TODO: Remove this when filesystem gets integrated into the dylib
+// REQUIRES: c++filesystem
+
+// <chrono>
+
+// file_clock
+
+// static time_point now() noexcept;
+
+#include <chrono>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    typedef std::chrono::file_clock C;
+    ASSERT_NOEXCEPT(C::now());
+
+    C::time_point t1 = C::now();
+    assert(t1.time_since_epoch().count() != 0);
+    assert(C::time_point::min() < t1);
+    assert(C::time_point::max() > t1);
+}
diff --git a/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
new file mode 100644
index 000000000..c0fa0b5be
--- /dev/null
+++ b/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// TODO: Remove this when filesystem gets integrated into the dylib
+// REQUIRES: c++filesystem
+
+// <chrono>
+
+// file_clock
+
+// rep should be signed
+
+#include <chrono>
+#include <cassert>
+
+int main()
+{
+    static_assert(std::is_signed<std::chrono::file_clock::rep>::value, "");
+    assert(std::chrono::file_clock::duration::min() <
+           std::chrono::file_clock::duration::zero());
+}
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index 25e6cdfe4..88aa56e38 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -282,7 +282,7 @@
 	<tr><td><a href="https://wg21.link/LWG3132">3132</a></td><td>Library needs to ban macros named <tt>expects</tt> or <tt>ensures</tt></td><td>San Diego</td><td><i>Nothing to do</i></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3134">3134</a></td><td>[fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961</td><td>San Diego</td><td>Resolved by P1210R0</td></tr>
 	<tr><td><a href="https://wg21.link/LWG3137">3137</a></td><td>Header for <tt>__cpp_lib_to_chars</tt></td><td>San Diego</td><td><i>We've already made the update; but we don't support all the test macros. When we do, this will be closed</i></td></tr>
-	<tr><td><a href="https://wg21.link/LWG3145">3145</a></td><td><tt>file_clock</tt> breaks ABI for C++17 implementations</td><td>San Diego</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG3145">3145</a></td><td><tt>file_clock</tt> breaks ABI for C++17 implementations</td><td>San Diego</td><td>Complete</td></tr>
 	<tr><td><a href="https://wg21.link/LWG3147">3147</a></td><td>Definitions of "likely" and "unlikely" are likely to cause problems</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3148">3148</a></td><td><tt>&lt;concepts&gt;</tt> should be freestanding</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3153">3153</a></td><td><tt>Common</tt> and <tt>common_type</tt> have too little in common</td><td>San Diego</td><td></td></tr>
-- 
GitLab


From 3cf34d1caf53a2c286e7b5f869599be94c4ec559 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 04:09:01 +0000
Subject: [PATCH 008/137] Implement LWG 3065: Make path operators friends.

This prevents things like:

using namespace std::filesystem;
auto x = L"a/b" == std::string("a/b");

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349884 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/filesystem                            | 62 ++++++++-----------
 .../path.nonmember/append_op.fail.cpp         | 27 ++++++++
 .../path.nonmember/append_op.pass.cpp         |  4 +-
 .../path.nonmember/comparison_ops.fail.cpp    | 33 ++++++++++
 www/cxx2a_status.html                         |  2 +-
 5 files changed, 89 insertions(+), 39 deletions(-)
 create mode 100644 test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
 create mode 100644 test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp

diff --git a/include/filesystem b/include/filesystem
index 06a0eb33c..af713a063 100644
--- a/include/filesystem
+++ b/include/filesystem
@@ -1151,6 +1151,31 @@ public:
     return __is;
   }
 
+  friend _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs, const path& __rhs) noexcept {
+    return __lhs.compare(__rhs) == 0;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs, const path& __rhs) noexcept {
+    return __lhs.compare(__rhs) != 0;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs, const path& __rhs) noexcept {
+    return __lhs.compare(__rhs) < 0;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool operator<=(const path& __lhs, const path& __rhs) noexcept {
+    return __lhs.compare(__rhs) <= 0;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool operator>(const path& __lhs, const path& __rhs) noexcept {
+    return __lhs.compare(__rhs) > 0;
+  }
+  friend _LIBCPP_INLINE_VISIBILITY bool operator>=(const path& __lhs, const path& __rhs) noexcept {
+    return __lhs.compare(__rhs) >= 0;
+  }
+
+  friend _LIBCPP_INLINE_VISIBILITY path operator/(const path& __lhs,
+                                                  const path& __rhs) {
+    path __result(__lhs);
+    __result /= __rhs;
+    return __result;
+  }
 private:
   inline _LIBCPP_INLINE_VISIBILITY path&
   __assign_view(__string_view const& __s) noexcept {
@@ -1167,43 +1192,6 @@ inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept {
 _LIBCPP_FUNC_VIS
 size_t hash_value(const path& __p) noexcept;
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs,
-                                                 const path& __rhs) noexcept {
-  return __lhs.compare(__rhs) == 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs,
-                                                 const path& __rhs) noexcept {
-  return __lhs.compare(__rhs) != 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs,
-                                                const path& __rhs) noexcept {
-  return __lhs.compare(__rhs) < 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY bool operator<=(const path& __lhs,
-                                                 const path& __rhs) noexcept {
-  return __lhs.compare(__rhs) <= 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY bool operator>(const path& __lhs,
-                                                const path& __rhs) noexcept {
-  return __lhs.compare(__rhs) > 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY bool operator>=(const path& __lhs,
-                                                 const path& __rhs) noexcept {
-  return __lhs.compare(__rhs) >= 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY path operator/(const path& __lhs,
-                                                const path& __rhs) {
-  path __result(__lhs);
-  __result /= __rhs;
-  return __result;
-}
-
 template <class _Source>
 _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_pathable<_Source>::value, path>::type
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
new file mode 100644
index 000000000..e0b3a959c
--- /dev/null
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+#include "filesystem_include.hpp"
+
+using namespace fs;
+
+struct ConvToPath {
+  operator fs::path() const {
+    return "";
+  }
+};
+
+int main() {
+  ConvToPath LHS, RHS;
+  (void)(LHS / RHS); // expected-error {{invalid operands to binary expression}}
+}
\ No newline at end of file
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
index 09498bf21..2a291d61d 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
@@ -20,7 +20,6 @@
 #include "test_macros.h"
 #include "filesystem_test_helper.hpp"
 
-
 // This is mainly tested via the member append functions.
 int main()
 {
@@ -29,4 +28,7 @@ int main()
   path p2("def");
   path p3 = p1 / p2;
   assert(p3 == "abc/def");
+
+  path p4 = p1 / "def";
+  assert(p4 == "abc/def");
 }
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
new file mode 100644
index 000000000..00eafe532
--- /dev/null
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <filesystem>
+
+
+#include "filesystem_include.hpp"
+
+using namespace fs;
+
+struct ConvToPath {
+  operator fs::path() const {
+    return "";
+  }
+};
+
+int main() {
+  ConvToPath LHS, RHS;
+  (void)(LHS == RHS); // expected-error {{invalid operands to binary expression}}
+  (void)(LHS != RHS); // expected-error {{invalid operands to binary expression}}
+  (void)(LHS < RHS); // expected-error {{invalid operands to binary expression}}
+  (void)(LHS <= RHS); // expected-error {{invalid operands to binary expression}}
+  (void)(LHS > RHS); // expected-error {{invalid operands to binary expression}}
+  (void)(LHS >= RHS); // expected-error {{invalid operands to binary expression}}
+}
\ No newline at end of file
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index 88aa56e38..1a072c9b0 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -270,7 +270,7 @@
 	<tr><td><a href="https://wg21.link/LWG3037">3037</a></td><td><tt>polymorphic_allocator</tt> and incomplete types</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3038">3038</a></td><td><tt>polymorphic_allocator::allocate</tt> should not allow integer overflow to create vulnerabilities</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3054">3054</a></td><td><tt>uninitialized_copy</tt> appears to not be able to meet its exception-safety guarantee</td><td>San Diego</td><td></td></tr>
-	<tr><td><a href="https://wg21.link/LWG3065">3065</a></td><td>LWG 2989 missed that all <tt>path</tt>'s other operators should be hidden friends as well</td><td>San Diego</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG3065">3065</a></td><td>LWG 2989 missed that all <tt>path</tt>'s other operators should be hidden friends as well</td><td>San Diego</td><td>Complete</td></tr>
 	<tr><td><a href="https://wg21.link/LWG3096">3096</a></td><td><tt>path::lexically_relative</tt> is confused by trailing slashes</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3116">3116</a></td><td><tt><i>OUTERMOST_ALLOC_TRAITS</i></tt> needs <tt>remove_reference_t</tt></td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3122">3122</a></td><td><tt>__cpp_lib_chrono_udls</tt> was accidentally dropped</td><td>San Diego</td><td><i>We've already made the update; but we don't support all the test macros. When we do, this will be closed</i></td></tr>
-- 
GitLab


From da05bdc85c1b8ef6e14f95a74d426256132eba81 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 04:25:40 +0000
Subject: [PATCH 009/137] Implement LWG 3096: path::lexically_relative is
 confused by trailing slashes

path("/dir/").lexically_relative("/dir"); now returns "." instead of ""

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349885 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/filesystem/operations.cpp                            | 9 ++++++---
 .../path.gen/lexically_relative_and_proximate.pass.cpp   | 4 ++--
 www/cxx2a_status.html                                    | 2 +-
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/filesystem/operations.cpp b/src/filesystem/operations.cpp
index 0b79ef1cd..e3bbc7b64 100644
--- a/src/filesystem/operations.cpp
+++ b/src/filesystem/operations.cpp
@@ -1478,7 +1478,7 @@ static int DetermineLexicalElementCount(PathParser PP) {
     auto Elem = *PP;
     if (Elem == "..")
       --Count;
-    else if (Elem != ".")
+    else if (Elem != "." && Elem != "")
       ++Count;
   }
   return Count;
@@ -1492,8 +1492,7 @@ path path::lexically_relative(const path& base) const {
       return PP.State != PPBase.State &&
              (PP.inRootPath() || PPBase.inRootPath());
     };
-    if (PP.State == PathParser::PS_InRootName &&
-        PPBase.State == PathParser::PS_InRootName) {
+    if (PP.inRootName() && PPBase.inRootName()) {
       if (*PP != *PPBase)
         return {};
     } else if (CheckIterMismatchAtBase())
@@ -1525,6 +1524,10 @@ path path::lexically_relative(const path& base) const {
   if (ElemCount < 0)
     return {};
 
+  // if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
+  if (ElemCount == 0 && (PP.atEnd() || *PP == ""))
+    return ".";
+
   // return a path constructed with 'n' dot-dot elements, followed by the the
   // elements of '*this' after the mismatch.
   path Result;
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
index 52c577bc8..f4e1d2f74 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
@@ -40,8 +40,8 @@ int main() {
       {"a", "/", ""},
       {"//net", "a", ""},
       {"a", "//net", ""},
-      {"//net/", "//net", ""},
-      {"//net", "//net/", ".."},
+      {"//net/", "//net", "."},
+      {"//net", "//net/", "."},
       {"//base", "a", ""},
       {"a", "a", "."},
       {"a/b", "a/b", "."},
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index 1a072c9b0..63ae029ed 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -271,7 +271,7 @@
 	<tr><td><a href="https://wg21.link/LWG3038">3038</a></td><td><tt>polymorphic_allocator::allocate</tt> should not allow integer overflow to create vulnerabilities</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3054">3054</a></td><td><tt>uninitialized_copy</tt> appears to not be able to meet its exception-safety guarantee</td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3065">3065</a></td><td>LWG 2989 missed that all <tt>path</tt>'s other operators should be hidden friends as well</td><td>San Diego</td><td>Complete</td></tr>
-	<tr><td><a href="https://wg21.link/LWG3096">3096</a></td><td><tt>path::lexically_relative</tt> is confused by trailing slashes</td><td>San Diego</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG3096">3096</a></td><td><tt>path::lexically_relative</tt> is confused by trailing slashes</td><td>San Diego</td><td>Complete</td></tr>
 	<tr><td><a href="https://wg21.link/LWG3116">3116</a></td><td><tt><i>OUTERMOST_ALLOC_TRAITS</i></tt> needs <tt>remove_reference_t</tt></td><td>San Diego</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3122">3122</a></td><td><tt>__cpp_lib_chrono_udls</tt> was accidentally dropped</td><td>San Diego</td><td><i>We've already made the update; but we don't support all the test macros. When we do, this will be closed</i></td></tr>
 	<tr><td><a href="https://wg21.link/LWG3127">3127</a></td><td><tt>basic_osyncstream::rdbuf</tt> needs a <tt>const_cast</tt></td><td>San Diego</td><td></td></tr>
-- 
GitLab


From fdb4802a742b4ad1201a8d55ca13e407d8df3c73 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 04:27:45 +0000
Subject: [PATCH 010/137] Fix copy paste error in file_clock tests

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349886 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../time/time.clock/time.clock.file/consistency.pass.cpp    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
index 275faa628..0b5757f67 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
@@ -25,11 +25,11 @@ void test(const T &) {}
 
 int main()
 {
-    typedef std::chrono::system_clock C;
+    typedef std::chrono::file_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
     static_assert((std::is_same<C::period, C::duration::period>::value), "");
     static_assert((std::is_same<C::duration, C::time_point::duration>::value), "");
     static_assert((std::is_same<C::time_point::clock, C>::value), "");
-    static_assert((C::is_steady || !C::is_steady), "");
-    test(std::chrono::system_clock::is_steady);
+    static_assert(!C::is_steady, "");
+    test(std::chrono::file_clock::is_steady);
 }
-- 
GitLab


From 1c5aabc9b7bc3c2a9c45f63b76d0b24684433da0 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 04:30:04 +0000
Subject: [PATCH 011/137] Don't forward declare _FilesystemClock in C++03

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349887 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/chrono | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/chrono b/include/chrono
index a5bb9afa8..cabf18c03 100644
--- a/include/chrono
+++ b/include/chrono
@@ -808,9 +808,11 @@ constexpr chrono::year                                  operator ""y(unsigned lo
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
+#ifndef _LIBCPP_CXX03_LANG
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 struct _FilesystemClock;
 _LIBCPP_END_NAMESPACE_FILESYSTEM
+#endif // !_LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-- 
GitLab


From 5f14fb5f341d0e1f47fc4ca2b048b2047476d501 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 21 Dec 2018 04:38:22 +0000
Subject: [PATCH 012/137] Fix test case breakages caused by lexically_relative
 change

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349888 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../fs.op.funcs/fs.op.proximate/proximate.pass.cpp          | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp
index 5f7b30dd6..ec4fc6d91 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp
@@ -75,12 +75,12 @@ TEST_CASE(basic_test) {
       {"a", parent_cwd, "fs.op.proximate/a"},
       {"/", "a", dot_dot_to_root / ".."},
       {"/", "a/b", dot_dot_to_root / "../.."},
-      {"/", "a/b/", dot_dot_to_root / "../../.."},
+      {"/", "a/b/", dot_dot_to_root / "../.."},
       {"a", "/", relative_cwd / "a"},
       {"a/b", "/", relative_cwd / "a/b"},
       {"a", "/net", ".." / relative_cwd / "a"},
-      {"//foo/", "//foo", "/foo/"},
-      {"//foo", "//foo/", ".."},
+      {"//foo/", "//foo", "."},
+      {"//foo", "//foo/", "."},
       {"//foo", "//foo", "."},
       {"//foo/", "//foo/", "."},
       {"//base", "a", dot_dot_to_root / "../base"},
-- 
GitLab


From 5de5c1197f034e032838228f357c444ce5cda1df Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Fri, 21 Dec 2018 17:32:23 +0000
Subject: [PATCH 013/137] [NFC] Fix typo in comment

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349932 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/variant | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/variant b/include/variant
index b33b1c40a..4a771dc63 100644
--- a/include/variant
+++ b/include/variant
@@ -1066,7 +1066,7 @@ public:
 #ifndef _LIBCPP_NO_EXCEPTIONS
       // EXTENSION: When the move construction of `__lhs` into `__rhs` throws
       // and `__tmp` is nothrow move constructible then we move `__tmp` back
-      // into `__rhs` and provide the strong exception safety guarentee.
+      // into `__rhs` and provide the strong exception safety guarantee.
       try {
         this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
       } catch (...) {
-- 
GitLab


From 8c8f0e1933a2cd12c6a07bbd63457d048efdac55 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Fri, 21 Dec 2018 20:14:43 +0000
Subject: [PATCH 014/137] [libcxx] Remove unused macro
 _LIBCPP_HAS_UNIQUE_TYPEINFO

Summary:
We already have the negation of that as _LIBCPP_HAS_NONUNIQUE_TYPEINFO.
Having both defined is confusing, since only one of them is used.

Reviewers: EricWF, mclow.lists

Subscribers: christof, jkorous, dexonsmith, libcxx-commits

Differential Revision: https://reviews.llvm.org/D54537

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349947 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/typeinfo | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/include/typeinfo b/include/typeinfo
index 92f1e2255..841153286 100644
--- a/include/typeinfo
+++ b/include/typeinfo
@@ -73,12 +73,8 @@ public:
 #include <vcruntime_typeinfo.h>
 #else
 
-#if !defined(_LIBCPP_ABI_MICROSOFT)
-#if defined(_LIBCPP_NONUNIQUE_RTTI_BIT)
-#define _LIBCPP_HAS_NONUNIQUE_TYPEINFO
-#else
-#define _LIBCPP_HAS_UNIQUE_TYPEINFO
-#endif
+#if defined(_LIBCPP_NONUNIQUE_RTTI_BIT) && !defined(_LIBCPP_ABI_MICROSOFT)
+#   define _LIBCPP_HAS_NONUNIQUE_TYPEINFO
 #endif
 
 namespace std  // purposefully not using versioning namespace
-- 
GitLab


From 51895bf735478464eaf17643e1235921594927f6 Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Sun, 30 Dec 2018 23:05:14 +0000
Subject: [PATCH 015/137] More tolerance for flaky tests in libc++ on NetBSD

Summary:
Tests marked with the flaky attribute ("FLAKY_TEST.")
can still report false positives in local tests and on the
NetBSD buildbot.

Additionally a number of tests (probably all threaded
ones) unmarked with the flaky attribute is flaky on
NetBSD.

An ideal solution on the libcxx side would be to raise
max retries for NetBSD and mark failing tests with
the flaky flag, however this adds more maintenance
burden and constant monitoring of flaky tests.

Reduce the work and handle flaky tests as more flaky
on NetBSD and allow flakiness  of other tests on
NetBSD.

Reviewers: mgorny, EricWF

Reviewed By: mgorny

Subscribers: christof, llvm-commits, libcxx-commits

Differential Revision: https://reviews.llvm.org/D56064

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350170 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/libcxx/test/format.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/utils/libcxx/test/format.py b/utils/libcxx/test/format.py
index 6a334ac31..46b2e46ac 100644
--- a/utils/libcxx/test/format.py
+++ b/utils/libcxx/test/format.py
@@ -12,6 +12,7 @@ import errno
 import os
 import time
 import random
+import platform
 
 import lit.Test        # pylint: disable=import-error
 import lit.TestRunner  # pylint: disable=import-error
@@ -202,6 +203,12 @@ class LibcxxTestFormat(object):
                           for f in os.listdir(local_cwd) if f.endswith('.dat')]
             is_flaky = self._get_parser('FLAKY_TEST.', parsers).getValue()
             max_retry = 3 if is_flaky else 1
+
+            # LIBC++ tests tend to be more flaky on NetBSD, so add more retries.
+            # We don't do this on other platforms because it's slower.
+            if platform.system() in ['NetBSD']:
+                max_retry = max_retry * 3
+
             for retry_count in range(max_retry):
                 cmd, out, err, rc = self.executor.run(exec_path, [exec_path],
                                                       local_cwd, data_files,
-- 
GitLab


From 7de83dce417ad2f8d3f9aa2293b9b37fb90b3990 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Thu, 3 Jan 2019 17:18:40 +0000
Subject: [PATCH 016/137] De-tab a couple tests. NFC

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350330 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../time/time.duration/time.duration.special/max.pass.cpp     | 4 ++--
 .../time/time.duration/time.duration.special/zero.pass.cpp    | 4 ++--
 .../utilities/time/time.point/time.point.special/max.pass.cpp | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
index 29b0e04c2..275f87760 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
@@ -23,9 +23,9 @@
 template <class D>
 void test()
 {
-	LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<typename D::rep>::max());
+    LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<typename D::rep>::max());
 #if TEST_STD_VER > 17
-	ASSERT_NOEXCEPT(       std::chrono::duration_values<typename D::rep>::max());
+    ASSERT_NOEXCEPT(       std::chrono::duration_values<typename D::rep>::max());
 #endif
     {
     typedef typename D::rep Rep;
diff --git a/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
index f9a4673db..a43bb099f 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
@@ -22,9 +22,9 @@
 template <class D>
 void test()
 {
-	LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<typename D::rep>::zero());
+    LIBCPP_ASSERT_NOEXCEPT(std::chrono::duration_values<typename D::rep>::zero());
 #if TEST_STD_VER > 17
-	ASSERT_NOEXCEPT(       std::chrono::duration_values<typename D::rep>::zero());
+    ASSERT_NOEXCEPT(       std::chrono::duration_values<typename D::rep>::zero());
 #endif
     {
     typedef typename D::rep Rep;
diff --git a/test/std/utilities/time/time.point/time.point.special/max.pass.cpp b/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
index 1d8d07964..85447ea41 100644
--- a/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
@@ -23,9 +23,9 @@ int main()
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
     typedef std::chrono::time_point<Clock, Duration> TP;
-	LIBCPP_ASSERT_NOEXCEPT(TP::max());
+    LIBCPP_ASSERT_NOEXCEPT(TP::max());
 #if TEST_STD_VER > 17
-	ASSERT_NOEXCEPT(       TP::max());
+    ASSERT_NOEXCEPT(       TP::max());
 #endif
     assert(TP::max() == TP(Duration::max()));
 }
-- 
GitLab


From 73aa3a89364fe300d1ce0e708fff88514e9da561 Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Sat, 5 Jan 2019 20:11:54 +0000
Subject: [PATCH 017/137] Revert "D56064: More tolerance for flaky tests in
 libc++ on NetBSD"

Requested by EricWF.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350477 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/libcxx/test/format.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/utils/libcxx/test/format.py b/utils/libcxx/test/format.py
index 46b2e46ac..6a334ac31 100644
--- a/utils/libcxx/test/format.py
+++ b/utils/libcxx/test/format.py
@@ -12,7 +12,6 @@ import errno
 import os
 import time
 import random
-import platform
 
 import lit.Test        # pylint: disable=import-error
 import lit.TestRunner  # pylint: disable=import-error
@@ -203,12 +202,6 @@ class LibcxxTestFormat(object):
                           for f in os.listdir(local_cwd) if f.endswith('.dat')]
             is_flaky = self._get_parser('FLAKY_TEST.', parsers).getValue()
             max_retry = 3 if is_flaky else 1
-
-            # LIBC++ tests tend to be more flaky on NetBSD, so add more retries.
-            # We don't do this on other platforms because it's slower.
-            if platform.system() in ['NetBSD']:
-                max_retry = max_retry * 3
-
             for retry_count in range(max_retry):
                 cmd, out, err, rc = self.executor.run(exec_path, [exec_path],
                                                       local_cwd, data_files,
-- 
GitLab


From 936dd3d1fffaa6464d05d5cce70800448c276e09 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sat, 5 Jan 2019 21:18:10 +0000
Subject: [PATCH 018/137] Fix flaky symlink access time test.

last_write_time(sym, new_time) changes the modification time of the file
referenced by the symlink. But reading through the symlink may change the
symlinks's access time.

This meant the previous test that checked that the symlinks access
time was unchanged was incorrect and made the test flaky.

This patch removes this test (there really is no non-flaky way
to test that the new access time coorisponds to the time at which
the symlink was last dereferenced). This should unflake the test.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350478 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../fs.op.last_write_time/last_write_time.pass.cpp   | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
index 11152e6ab..bf0096acf 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
@@ -125,7 +125,7 @@ TimeSpec LastAccessTime(path const& p) { return GetTimes(p).access; }
 
 TimeSpec LastWriteTime(path const& p) { return GetTimes(p).write; }
 
-std::pair<TimeSpec, TimeSpec> GetSymlinkTimes(path const& p) {
+Times GetSymlinkTimes(path const& p) {
   StatT st;
   if (::lstat(p.c_str(), &st) == -1) {
     std::error_code ec(errno, std::generic_category());
@@ -136,7 +136,10 @@ std::pair<TimeSpec, TimeSpec> GetSymlinkTimes(path const& p) {
         std::exit(EXIT_FAILURE);
 #endif
     }
-    return {extract_atime(st), extract_mtime(st)};
+    Times res;
+    res.access = extract_atime(st);
+    res.write = extract_mtime(st);
+    return res;
 }
 
 namespace {
@@ -500,9 +503,8 @@ TEST_CASE(last_write_time_symlink_test)
 
     TEST_CHECK(CompareTime(LastWriteTime(file), new_time));
     TEST_CHECK(CompareTime(LastAccessTime(sym), old_times.access));
-    std::pair<TimeSpec, TimeSpec> sym_times = GetSymlinkTimes(sym);
-    TEST_CHECK(CompareTime(sym_times.first, old_sym_times.first));
-    TEST_CHECK(CompareTime(sym_times.second, old_sym_times.second));
+    Times sym_times = GetSymlinkTimes(sym);
+    TEST_CHECK(CompareTime(sym_times.write, old_sym_times.write));
 }
 
 
-- 
GitLab


From 642080354947e0606992aa091ce5e1b4e1e4179d Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 6 Jan 2019 00:37:31 +0000
Subject: [PATCH 019/137] Fix PR39749 - Headers containing just #error harm
 __has_include.

This patch changes <experimental/foo> to use #warning instead of
is harmful to common feature detection idioms.

We should also consider only emitting the warning when __DEPRECATED is
defined, like we do in the <ext/foo> headers. Users may want to specify
"-Werror=-W#warnings" while still ignoring the libc++ warnings.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350485 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/experimental/any                      | 18 ++++++++++++----
 include/experimental/chrono                   | 18 ++++++++++++----
 include/experimental/numeric                  | 12 ++++++++++-
 include/experimental/optional                 | 12 ++++++++++-
 include/experimental/ratio                    | 18 ++++++++++++----
 include/experimental/string_view              | 16 +++++++++++---
 include/experimental/system_error             | 12 ++++++++++-
 include/experimental/tuple                    | 12 ++++++++++-
 .../syserr/use_header_warning.fail.cpp        | 18 ++++++++++++++++
 .../diagnostics/syserr/version.pass.cpp       | 21 +++++++++++++++++++
 .../numeric.ops/use_header_warning.fail.cpp   | 18 ++++++++++++++++
 .../numerics/numeric.ops/version.pass.cpp     | 21 +++++++++++++++++++
 .../string.view/use_header_warning.fail.cpp   | 18 ++++++++++++++++
 .../strings/string.view/version.pass.cpp      | 21 +++++++++++++++++++
 .../utilities/any/use_header_warning.fail.cpp | 18 ++++++++++++++++
 .../utilities/any/version.pass.cpp            | 21 +++++++++++++++++++
 .../optional/use_header_warning.fail.cpp      | 18 ++++++++++++++++
 .../utilities/optional/version.pass.cpp       | 21 +++++++++++++++++++
 .../ratio/use_header_warning.fail.cpp         | 18 ++++++++++++++++
 .../utilities/ratio/version.pass.cpp          | 21 +++++++++++++++++++
 .../time/use_header_warning.fail.cpp          | 18 ++++++++++++++++
 .../utilities/time/version.pass.cpp           | 21 +++++++++++++++++++
 .../tuple/use_header_warning.fail.cpp         | 18 ++++++++++++++++
 .../utilities/tuple/version.pass.cpp          | 21 +++++++++++++++++++
 24 files changed, 411 insertions(+), 19 deletions(-)
 create mode 100644 test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
 create mode 100644 test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
 create mode 100644 test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/strings/string.view/version.pass.cpp
 create mode 100644 test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/utilities/any/version.pass.cpp
 create mode 100644 test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/utilities/optional/version.pass.cpp
 create mode 100644 test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/utilities/ratio/version.pass.cpp
 create mode 100644 test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/utilities/time/version.pass.cpp
 create mode 100644 test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
 create mode 100644 test/libcxx/experimental/utilities/tuple/version.pass.cpp

diff --git a/include/experimental/any b/include/experimental/any
index 1dcdd0f25..d9c953425 100644
--- a/include/experimental/any
+++ b/include/experimental/any
@@ -1,11 +1,21 @@
 // -*- C++ -*-
-//===------------------------------ any -----------------------------------===//
+//===------------------------------- any ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_ANY
+#define _LIBCPP_EXPERIMENTAL_ANY
 
-#error "<experimental/any> has been removed. Use <any> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/any> has been removed. Use <any> instead.")
+#else
+# warning "<experimental/any> has been removed. Use <any> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_ANY
diff --git a/include/experimental/chrono b/include/experimental/chrono
index 591cf7160..30c7e4a9d 100644
--- a/include/experimental/chrono
+++ b/include/experimental/chrono
@@ -1,11 +1,21 @@
 // -*- C++ -*-
-//===------------------------------ chrono ---------------------------------===//
+//===---------------------------- chrono ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_CHRONO
+#define _LIBCPP_EXPERIMENTAL_CHRONO
 
-#error "<experimental/chrono> has been removed. Use <chrono> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/chrono> has been removed. Use <chrono> instead.")
+#else
+# warning "<experimental/chrono> has been removed. Use <chrono> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_CHRONO
diff --git a/include/experimental/numeric b/include/experimental/numeric
index 14a664011..19c65313f 100644
--- a/include/experimental/numeric
+++ b/include/experimental/numeric
@@ -7,5 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_NUMERIC
+#define _LIBCPP_EXPERIMENTAL_NUMERIC
 
-#error "<experimental/numeric> has been removed. Use <numeric> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/numeric> has been removed. Use <numeric> instead.")
+#else
+# warning "<experimental/numeric> has been removed. Use <numeric> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_NUMERIC
diff --git a/include/experimental/optional b/include/experimental/optional
index d68cefdf6..6eb4a2618 100644
--- a/include/experimental/optional
+++ b/include/experimental/optional
@@ -7,5 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_OPTIONAL
+#define _LIBCPP_EXPERIMENTAL_OPTIONAL
 
-#error "<experimental/optional> has been removed. Use <optional> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/optional> has been removed. Use <optional> instead.")
+#else
+# warning "<experimental/optional> has been removed. Use <optional> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_OPTIONAL
diff --git a/include/experimental/ratio b/include/experimental/ratio
index 9c2bf2e46..52c12004d 100644
--- a/include/experimental/ratio
+++ b/include/experimental/ratio
@@ -1,11 +1,21 @@
 // -*- C++ -*-
-//===------------------------------ ratio ---------------------------------===//
+//===----------------------------- ratio ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_RATIO
+#define _LIBCPP_EXPERIMENTAL_RATIO
 
-#error "<experimental/ratio> has been removed. Use <ratio> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/ratio> has been removed. Use <ratio> instead.")
+#else
+# warning "<experimental/ratio> has been removed. Use <ratio> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_RATIO
diff --git a/include/experimental/string_view b/include/experimental/string_view
index f13bff54d..100bdfe72 100644
--- a/include/experimental/string_view
+++ b/include/experimental/string_view
@@ -3,9 +3,19 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_STRING_VIEW
+#define _LIBCPP_EXPERIMENTAL_STRING_VIEW
 
-#error "<experimental/string_view> has been removed. Use <string_view> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/string_view> has been removed. Use <string_view> instead.")
+#else
+# warning "<experimental/string_view> has been removed. Use <string_view> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_STRING_VIEW
diff --git a/include/experimental/system_error b/include/experimental/system_error
index 7937357fa..1cf84ee01 100644
--- a/include/experimental/system_error
+++ b/include/experimental/system_error
@@ -7,5 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
+#define _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
 
-#error "<experimental/system_error> has been removed. Use <system_error> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/system_error> has been removed. Use <system_error> instead.")
+#else
+# warning "<experimental/system_error> has been removed. Use <system_error> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
diff --git a/include/experimental/tuple b/include/experimental/tuple
index 1f37a6293..6d71bb559 100644
--- a/include/experimental/tuple
+++ b/include/experimental/tuple
@@ -7,5 +7,15 @@
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_TUPLE
+#define _LIBCPP_EXPERIMENTAL_TUPLE
 
-#error "<experimental/tuple> has been removed. Use <tuple> instead."
+#include <__config>
+
+#ifdef _LIBCPP_WARNING
+_LIBCPP_WARNING("<experimental/tuple> has been removed. Use <tuple> instead.")
+#else
+# warning "<experimental/tuple> has been removed. Use <tuple> instead."
+#endif
+
+#endif // _LIBCPP_EXPERIMENTAL_TUPLE
diff --git a/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp b/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
new file mode 100644
index 000000000..074a9c58c
--- /dev/null
+++ b/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/system_error>
+
+#include <experimental/system_error>
+
+// expected-error@experimental/system_error:* {{"<experimental/system_error> has been removed. Use <system_error> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp b/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
new file mode 100644
index 000000000..c4fb9593a
--- /dev/null
+++ b/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/system_error>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/system_error>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp b/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
new file mode 100644
index 000000000..32fd0527d
--- /dev/null
+++ b/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/numeric>
+
+#include <experimental/numeric>
+
+// expected-error@experimental/numeric:* {{"<experimental/numeric> has been removed. Use <numeric> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp b/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
new file mode 100644
index 000000000..37ac584a7
--- /dev/null
+++ b/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/numeric>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/numeric>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp b/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
new file mode 100644
index 000000000..64f737420
--- /dev/null
+++ b/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/string_view>
+
+#include <experimental/string_view>
+
+// expected-error@experimental/string_view:* {{"<experimental/string_view> has been removed. Use <string_view> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/strings/string.view/version.pass.cpp b/test/libcxx/experimental/strings/string.view/version.pass.cpp
new file mode 100644
index 000000000..417982e36
--- /dev/null
+++ b/test/libcxx/experimental/strings/string.view/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/string_view>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/string_view>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
new file mode 100644
index 000000000..0bcda7056
--- /dev/null
+++ b/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/any>
+
+#include <experimental/any>
+
+// expected-error@experimental/any:* {{"<experimental/any> has been removed. Use <any> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/any/version.pass.cpp b/test/libcxx/experimental/utilities/any/version.pass.cpp
new file mode 100644
index 000000000..bc37d8b4d
--- /dev/null
+++ b/test/libcxx/experimental/utilities/any/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/any>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/any>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
new file mode 100644
index 000000000..1711d2f03
--- /dev/null
+++ b/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/optional>
+
+#include <experimental/optional>
+
+// expected-error@experimental/optional:* {{"<experimental/optional> has been removed. Use <optional> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/optional/version.pass.cpp b/test/libcxx/experimental/utilities/optional/version.pass.cpp
new file mode 100644
index 000000000..ef011bbe4
--- /dev/null
+++ b/test/libcxx/experimental/utilities/optional/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/optional>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/optional>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
new file mode 100644
index 000000000..d9a01337a
--- /dev/null
+++ b/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/ratio>
+
+#include <experimental/ratio>
+
+// expected-error@experimental/ratio:* {{"<experimental/ratio> has been removed. Use <ratio> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/ratio/version.pass.cpp b/test/libcxx/experimental/utilities/ratio/version.pass.cpp
new file mode 100644
index 000000000..8ebb347a4
--- /dev/null
+++ b/test/libcxx/experimental/utilities/ratio/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/ratio>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/ratio>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
new file mode 100644
index 000000000..9f3d679fc
--- /dev/null
+++ b/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/chrono>
+
+#include <experimental/chrono>
+
+// expected-error@experimental/chrono:* {{"<experimental/chrono> has been removed. Use <chrono> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/time/version.pass.cpp b/test/libcxx/experimental/utilities/time/version.pass.cpp
new file mode 100644
index 000000000..5544a3f0e
--- /dev/null
+++ b/test/libcxx/experimental/utilities/time/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/chrono>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/chrono>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
new file mode 100644
index 000000000..520e9fbb4
--- /dev/null
+++ b/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: verify-support
+
+// <experimental/tuple>
+
+#include <experimental/tuple>
+
+// expected-error@experimental/tuple:* {{"<experimental/tuple> has been removed. Use <tuple> instead."}}
+
+int main() {}
diff --git a/test/libcxx/experimental/utilities/tuple/version.pass.cpp b/test/libcxx/experimental/utilities/tuple/version.pass.cpp
new file mode 100644
index 000000000..c7c9e5728
--- /dev/null
+++ b/test/libcxx/experimental/utilities/tuple/version.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/tuple>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-W#warnings"
+#endif
+#include <experimental/tuple>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}
-- 
GitLab


From 9e444eb82d34fd56af3875a6971dead607e20b9e Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Sun, 6 Jan 2019 06:14:31 +0000
Subject: [PATCH 020/137] [libcxx] Support building hermetic static library

This is useful when static libc++ library is being linked into
shared libraries that may be used in combination with libraries.
We want to avoid we exporting libc++ symbols in those cases where
this option is useful. This is provided as a CMake option and can
be enabled by libc++ vendors as needed.

Differential Revision: https://reviews.llvm.org/D55404

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350489 91177308-0d34-0410-b5e6-96231b3b80d8
---
 CMakeLists.txt          |  3 ++
 docs/BuildingLibcxx.rst |  9 ++++
 lib/CMakeLists.txt      | 93 ++++++++++++++++++++++++++---------------
 3 files changed, 72 insertions(+), 33 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d090860e4..a57e36fdd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -283,6 +283,9 @@ endif()
 option(LIBCXX_CONFIGURE_IDE "Configure libcxx for use within an IDE"
       ${LIBCXX_CONFIGURE_IDE_DEFAULT})
 
+option(LIBCXX_HERMETIC_STATIC_LIBRARY
+  "Do not export any symbols from the static library." OFF)
+
 #===============================================================================
 # Check option configurations
 #===============================================================================
diff --git a/docs/BuildingLibcxx.rst b/docs/BuildingLibcxx.rst
index c40e5fbcc..a498c0027 100644
--- a/docs/BuildingLibcxx.rst
+++ b/docs/BuildingLibcxx.rst
@@ -222,6 +222,15 @@ libc++ specific options
 
   Define libc++ destination prefix.
 
+.. option:: LIBCXX_HERMETIC_STATIC_LIBRARY:BOOL
+
+  **Default**: ``OFF``
+
+  Do not export any symbols from the static libc++ library. This is useful when
+  This is useful when the static libc++ library is being linked into shared
+  libraries that may be used in with other shared libraries that use different
+  C++ library. We want to avoid avoid exporting any libc++ symbols in that case.
+
 .. _libc++experimental options:
 
 libc++experimental Specific Options
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 354da21a5..24489e8fb 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -175,42 +175,69 @@ endif()
 split_list(LIBCXX_COMPILE_FLAGS)
 split_list(LIBCXX_LINK_FLAGS)
 
-# Add an object library that contains the compiled source files.
-add_library(cxx_objects OBJECT ${exclude_from_all} ${LIBCXX_SOURCES} ${LIBCXX_HEADERS})
-if(LIBCXX_CXX_ABI_HEADER_TARGET)
-  add_dependencies(cxx_objects ${LIBCXX_CXX_ABI_HEADER_TARGET})
-endif()
-if(WIN32 AND NOT MINGW)
-  target_compile_definitions(cxx_objects
-                             PRIVATE
-                               # Ignore the -MSC_VER mismatch, as we may build
-                               # with a different compatibility version.
-                               _ALLOW_MSC_VER_MISMATCH
-                               # Don't check the msvcprt iterator debug levels
-                               # as we will define the iterator types; libc++
-                               # uses a different macro to identify the debug
-                               # level.
-                               _ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH
-                               # We are building the c++ runtime, don't pull in
-                               # msvcprt.
-                               _CRTBLD
-                               # Don't warn on the use of "deprecated"
-                               # "insecure" functions which are standards
-                               # specified.
-                               _CRT_SECURE_NO_WARNINGS
-                               # Use the ISO conforming behaviour for conversion
-                               # in printf, scanf.
-                               _CRT_STDIO_ISO_WIDE_SPECIFIERS)
-endif()
+macro(cxx_object_library name)
+  cmake_parse_arguments(ARGS "" "" "DEFINES;FLAGS" ${ARGN})
+
+  # Add an object library that contains the compiled source files.
+  add_library(${name} OBJECT ${exclude_from_all} ${LIBCXX_SOURCES} ${LIBCXX_HEADERS})
+  if(LIBCXX_CXX_ABI_HEADER_TARGET)
+    add_dependencies(${name} ${LIBCXX_CXX_ABI_HEADER_TARGET})
+  endif()
+  if(WIN32 AND NOT MINGW)
+    target_compile_definitions(${name}
+                               PRIVATE
+                                 # Ignore the -MSC_VER mismatch, as we may build
+                                 # with a different compatibility version.
+                                 _ALLOW_MSC_VER_MISMATCH
+                                 # Don't check the msvcprt iterator debug levels
+                                 # as we will define the iterator types; libc++
+                                 # uses a different macro to identify the debug
+                                 # level.
+                                 _ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH
+                                 # We are building the c++ runtime, don't pull in
+                                 # msvcprt.
+                                 _CRTBLD
+                                 # Don't warn on the use of "deprecated"
+                                 # "insecure" functions which are standards
+                                 # specified.
+                                 _CRT_SECURE_NO_WARNINGS
+                                 # Use the ISO conforming behaviour for conversion
+                                 # in printf, scanf.
+                                 _CRT_STDIO_ISO_WIDE_SPECIFIERS)
+  endif()
+
+  if(ARGS_DEFINES)
+    target_compile_definitions(${name} PRIVATE ${ARGS_DEFINES})
+  endif()
 
-set_target_properties(cxx_objects
-  PROPERTIES
-    COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
-)
+  set_target_properties(${name}
+    PROPERTIES
+      COMPILE_FLAGS ${LIBCXX_COMPILE_FLAGS}
+  )
+
+  if(ARGS_FLAGS)
+    target_compile_options(${name} PRIVATE ${ARGS_FLAGS})
+  endif()
+endmacro()
+
+if(LIBCXX_HERMETIC_STATIC_LIBRARY)
+  append_flags_if_supported(CXX_STATIC_OBJECTS_FLAGS -fvisibility=hidden)
+  append_flags_if_supported(CXX_STATIC_OBJECTS_FLAGS -fvisibility-global-new-delete-hidden)
+  cxx_object_library(cxx_static_objects
+    DEFINES _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+    FLAGS ${CXX_STATIC_OBJECTS_FLAGS})
+  cxx_object_library(cxx_shared_objects)
+  set(cxx_static_sources $<TARGET_OBJECTS:cxx_static_objects>)
+  set(cxx_shared_sources $<TARGET_OBJECTS:cxx_shared_objects>)
+else()
+  cxx_object_library(cxx_objects)
+  set(cxx_static_sources $<TARGET_OBJECTS:cxx_objects>)
+  set(cxx_shared_sources $<TARGET_OBJECTS:cxx_objects>)
+endif()
 
 # Build the shared library.
 if (LIBCXX_ENABLE_SHARED)
-  add_library(cxx_shared SHARED $<TARGET_OBJECTS:cxx_objects>)
+  add_library(cxx_shared SHARED ${cxx_shared_sources})
   if(COMMAND llvm_setup_rpath)
     llvm_setup_rpath(cxx_shared)
   endif()
@@ -237,7 +264,7 @@ endif()
 
 # Build the static library.
 if (LIBCXX_ENABLE_STATIC)
-  add_library(cxx_static STATIC $<TARGET_OBJECTS:cxx_objects>)
+  add_library(cxx_static STATIC ${cxx_static_sources})
   target_link_libraries(cxx_static ${LIBCXX_LIBRARIES})
   set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
   set_target_properties(cxx_static
-- 
GitLab


From a9c67b27fa54485b6e63fb5a8d3d14d74c2b5479 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Mon, 7 Jan 2019 16:17:52 +0000
Subject: [PATCH 021/137] Add the feature test macros that were defined in
 p1353r0 to the headers of the appropriate tests. No actual tests yet, so NFC.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350535 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../compare.version.pass.cpp                  | 32 +++++++++++++++++++
 .../new.version.pass.cpp                      |  2 +-
 .../version.version.pass.cpp                  |  2 ++
 3 files changed, 35 insertions(+), 1 deletion(-)
 create mode 100644 test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp

diff --git a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
new file mode 100644
index 000000000..eff2cb293
--- /dev/null
+++ b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// <new> feature macros
+
+/*  Constant                                    Value
+    __cpp_lib_three_way_comparison              201711L
+
+*/
+
+#include <compare>
+#include <cassert>
+#include "test_macros.h"
+
+int main()
+{
+//  ensure that the macros that are supposed to be defined in <compare> are defined.
+
+/*
+#if !defined(__cpp_lib_fooby)
+# error "__cpp_lib_fooby is not defined"
+#elif __cpp_lib_fooby < 201606L
+# error "__cpp_lib_fooby has an invalid value"
+#endif
+*/
+}
diff --git a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
index 856bd8b01..6bcd242d1 100644
--- a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -11,6 +10,7 @@
 // <new> feature macros
 
 /*  Constant                                    Value
+    __cpp_lib_destroying_delete                 201806L
     __cpp_lib_hardware_interference_size        201703L
     __cpp_lib_launder                           201606L
 
diff --git a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
index e2179e08a..29fe4b298 100644
--- a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -29,6 +29,7 @@
     __cpp_lib_complex_udls                      201309L
     __cpp_lib_concepts                          201806L
     __cpp_lib_constexpr_swap_algorithms         201806L
+    __cpp_lib_destroying_delete                 201806L
     __cpp_lib_enable_shared_from_this           201603L
     __cpp_lib_exchange_function                 201304L
     __cpp_lib_execution                         201603L
@@ -75,6 +76,7 @@
     __cpp_lib_string_udls                       201304L
     __cpp_lib_string_view                       201606L
     __cpp_lib_to_chars                          201611L
+    __cpp_lib_three_way_comparison              201711L
     __cpp_lib_transformation_trait_aliases      201304L
     __cpp_lib_transparent_operators             201510L
     __cpp_lib_tuple_element_t                   201402L
-- 
GitLab


From 4626eac620fdf0297d04152335fe6970974b82ea Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Mon, 7 Jan 2019 18:21:18 +0000
Subject: [PATCH 022/137] Mark more tests as flaky

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350550 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.condition/thread.condition.condvar/wait_for.pass.cpp | 2 ++
 .../thread.condition.condvarany/notify_one.pass.cpp             | 2 ++
 .../thread.lock.shared.cons/mutex_try_to_lock.pass.cpp          | 2 ++
 .../thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp   | 2 ++
 .../thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp | 2 ++
 5 files changed, 10 insertions(+)

diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
index ca48eee19..8aa233f66 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
@@ -9,6 +9,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST
+
 // <condition_variable>
 
 // class condition_variable;
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
index 98f6c432c..16e6ff9f1 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
@@ -9,6 +9,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST
+
 // <condition_variable>
 
 // class condition_variable_any;
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
index 7f89f0af8..694e311b7 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
@@ -10,6 +10,8 @@
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
+// FLAKY_TEST
+
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
index dcfdfd11a..f63256373 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
@@ -9,6 +9,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST
+
 // <mutex>
 
 // template <class Mutex> class unique_lock;
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
index cb5c55925..ebaf3e6de 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
@@ -9,6 +9,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST
+
 // <mutex>
 
 // template <class Mutex> class unique_lock;
-- 
GitLab


From 354589c472c3f14136aa1f915d6e6dae82c1f4d8 Mon Sep 17 00:00:00 2001
From: Volodymyr Sapsai <vsapsai@apple.com>
Date: Tue, 8 Jan 2019 00:03:16 +0000
Subject: [PATCH 023/137] [libcxx] Optimize vectors construction of trivial
 types from an iterator range with const-ness mismatch.

We already have a specialization that will use memcpy for construction
of trivial types from an iterator range like

    std::vector<int>(int *, int *);

But if we have const-ness mismatch like

    std::vector<int>(const int *, const int *);

we would use a slow path that copies each element individually. This change
enables the optimal specialization for const-ness mismatch. Fixes PR37574.

Contributions to the patch are made by Arthur O'Dwyer, Louis Dionne.

rdar://problem/40485845

Reviewers: mclow.lists, EricWF, ldionne, scanon

Reviewed By: ldionne

Subscribers: christof, ldionne, howard.hinnant, cfe-commits

Differential Revision: https://reviews.llvm.org/D48342



git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350583 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/memory                                | 26 ++++++++++------
 .../vector.cons/construct_iter_iter.pass.cpp  | 31 +++++++++++++++++++
 2 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/include/memory b/include/memory
index b012f5bce..93f04c6fa 100644
--- a/include/memory
+++ b/include/memory
@@ -1502,6 +1502,12 @@ struct __alloc_traits_difference_type<_Alloc, _Ptr, true>
     typedef typename _Alloc::difference_type type;
 };
 
+template <class _Tp>
+struct __is_default_allocator : false_type {};
+
+template <class _Tp>
+struct __is_default_allocator<_VSTD::allocator<_Tp> > : true_type {};
+
 template <class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS allocator_traits
 {
@@ -1615,7 +1621,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
         static
         typename enable_if
         <
-            (is_same<allocator_type, allocator<_Tp> >::value
+            (__is_default_allocator<allocator_type>::value
                 || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
              is_trivially_move_constructible<_Tp>::value,
             void
@@ -1640,23 +1646,25 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
                 construct(__a, _VSTD::__to_raw_pointer(__begin2), *__begin1);
         }
 
-    template <class _Tp>
+    template <class _SourceTp, class _DestTp,
+              class _RawSourceTp = typename remove_const<_SourceTp>::type,
+              class _RawDestTp = typename remove_const<_DestTp>::type>
         _LIBCPP_INLINE_VISIBILITY
         static
         typename enable_if
         <
-            (is_same<allocator_type, allocator<_Tp> >::value
-                || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
-             is_trivially_move_constructible<_Tp>::value,
+            is_trivially_move_constructible<_DestTp>::value &&
+            is_same<_RawSourceTp, _RawDestTp>::value &&
+            (__is_default_allocator<allocator_type>::value ||
+             !__has_construct<allocator_type, _DestTp*, _SourceTp&>::value),
             void
         >::type
-        __construct_range_forward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
+        __construct_range_forward(allocator_type&, _SourceTp* __begin1, _SourceTp* __end1, _DestTp*& __begin2)
         {
-            typedef typename remove_const<_Tp>::type _Vp;
             ptrdiff_t _Np = __end1 - __begin1;
             if (_Np > 0)
             {
-                _VSTD::memcpy(const_cast<_Vp*>(__begin2), __begin1, _Np * sizeof(_Tp));
+                _VSTD::memcpy(const_cast<_RawDestTp*>(__begin2), __begin1, _Np * sizeof(_DestTp));
                 __begin2 += _Np;
             }
         }
@@ -1679,7 +1687,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
         static
         typename enable_if
         <
-            (is_same<allocator_type, allocator<_Tp> >::value
+            (__is_default_allocator<allocator_type>::value
                 || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
              is_trivially_move_constructible<_Tp>::value,
             void
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index 21a7df4a7..60fe2899a 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -146,9 +146,40 @@ void test_ctor_under_alloc() {
 #endif
 }
 
+// Initialize a vector with a different value type.
+void test_ctor_with_different_value_type() {
+  {
+    // Make sure initialization is performed with each element value, not with
+    // a memory blob.
+    float array[3] = {0.0f, 1.0f, 2.0f};
+    std::vector<int> v(array, array + 3);
+    assert(v[0] == 0);
+    assert(v[1] == 1);
+    assert(v[2] == 2);
+  }
+  struct X { int x; };
+  struct Y { int y; };
+  struct Z : X, Y { int z; };
+  {
+    Z z;
+    Z *array[1] = { &z };
+    // Though the types Z* and Y* are very similar, initialization still cannot
+    // be done with `memcpy`.
+    std::vector<Y*> v(array, array + 1);
+    assert(v[0] == &z);
+  }
+  {
+    // Though the types are different, initialization can be done with `memcpy`.
+    int32_t array[1] = { -1 };
+    std::vector<uint32_t> v(array, array + 1);
+    assert(v[0] == 4294967295);
+  }
+}
+
 
 int main() {
   basic_test_cases();
   emplaceable_concept_tests(); // See PR34898
   test_ctor_under_alloc();
+  test_ctor_with_different_value_type();
 }
-- 
GitLab


From 11a8815e5aedc2706a3244cfd4d470253a619ac4 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Tue, 8 Jan 2019 02:48:45 +0000
Subject: [PATCH 024/137] Set the buffer of an fstream to empty when the
 underlying file is closed. This 'fixes' PR#38052 - std::fstream still good
 after closing and updating content.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350603 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/fstream                               |  1 +
 .../fstreams/fstream.close.pass.cpp           | 35 +++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp

diff --git a/include/fstream b/include/fstream
index 332b4747c..711e484e2 100644
--- a/include/fstream
+++ b/include/fstream
@@ -702,6 +702,7 @@ basic_filebuf<_CharT, _Traits>::close()
             __file_ = 0;
         else
             __rt = 0;
+        setbuf(0, 0);
     }
     return __rt;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
new file mode 100644
index 000000000..0f8defcbd
--- /dev/null
+++ b/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// <fstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_fstream
+
+// close();
+
+//	Inspired by PR#38052 - std::fstream still good after closing and updating content
+
+#include <fstream>
+#include <cassert>
+#include "platform_support.h"
+
+int main()
+{
+    std::string temp = get_temp_file_name();
+
+    std::fstream ofs(temp, std::ios::out | std::ios::trunc);
+    ofs << "Hello, World!\n";
+    assert( ofs.good());
+    ofs.close();
+    assert( ofs.good());
+    ofs << "Hello, World!\n";
+    assert(!ofs.good());
+
+    std::remove(temp.c_str());
+}
-- 
GitLab


From ed1d77ad35412febe364bbee6d5aeeee8e4eb981 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 8 Jan 2019 20:26:56 +0000
Subject: [PATCH 025/137] [Sema] Teach Clang that aligned allocation is not
 supported with macosx10.13

Summary:
r306722 added diagnostics when aligned allocation is used with deployment
targets that do not support it, but the first macosx supporting aligned
allocation was incorrectly set to 10.13. In reality, the dylib shipped
with macosx10.13 does not support aligned allocation, but the dylib
shipped with macosx10.14 does.

Reviewers: ahatanak

Subscribers: christof, jkorous, dexonsmith, cfe-commits

Differential Revision: https://reviews.llvm.org/D56445

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350649 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../support.dynamic/libcpp_deallocate.sh.cpp  |  8 +++++++-
 .../memory/aligned_allocation_macro.pass.cpp  | 19 +++++++++++--------
 2 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
index 0e28d61ef..414a75b33 100644
--- a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
+++ b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
@@ -14,9 +14,15 @@
 // definitions, which does not yet provide aligned allocation
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// Clang 10 (and older) will trigger an availability error when the deployment
+// AppleClang 10 (and older) will trigger an availability error when the deployment
 // target does not support aligned allocation, even if we pass `-faligned-allocation`.
+// XFAIL: apple-clang-10 && availability=macosx10.13
 // XFAIL: apple-clang-10 && availability=macosx10.12
+// XFAIL: apple-clang-10 && availability=macosx10.11
+// XFAIL: apple-clang-10 && availability=macosx10.10
+// XFAIL: apple-clang-10 && availability=macosx10.9
+// XFAIL: apple-clang-10 && availability=macosx10.8
+// XFAIL: apple-clang-10 && availability=macosx10.7
 
 // The dylibs shipped before macosx10.14 do not contain the aligned allocation
 // functions, so trying to force using those with -faligned-allocation results
diff --git a/test/libcxx/memory/aligned_allocation_macro.pass.cpp b/test/libcxx/memory/aligned_allocation_macro.pass.cpp
index 5390bef3e..368076dee 100644
--- a/test/libcxx/memory/aligned_allocation_macro.pass.cpp
+++ b/test/libcxx/memory/aligned_allocation_macro.pass.cpp
@@ -9,14 +9,17 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// Aligned allocation functions are not provided prior to macosx10.13, but
-// AppleClang <= 10 does not know about this restriction and always enables them.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.9
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.8
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.7
+// AppleClang <= 10 enables aligned allocation regardless of the deployment
+// target, so this test would fail.
+// UNSUPPORTED: apple-clang-9, apple-clang-10
+
+// XFAIL: availability=macosx10.13
+// XFAIL: availability=macosx10.12
+// XFAIL: availability=macosx10.11
+// XFAIL: availability=macosx10.10
+// XFAIL: availability=macosx10.9
+// XFAIL: availability=macosx10.8
+// XFAIL: availability=macosx10.7
 
 #include <new>
 
-- 
GitLab


From cd72c529808c18ac620c86705b92b6006a6d4780 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 9 Jan 2019 05:48:54 +0000
Subject: [PATCH 026/137] Mark two more tests as FLAKY

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350692 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.lock/thread.lock.guard/adopt_lock.pass.cpp           | 2 ++
 .../thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp   | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
index 83271009a..79c639eb6 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
@@ -9,6 +9,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST
+
 // <mutex>
 
 // template <class Mutex> class lock_guard;
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
index 97f9d07c1..4a2db39e8 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
@@ -9,6 +9,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST
+
 // <mutex>
 
 // template <class Mutex> class lock_guard;
-- 
GitLab


From ee53ced93ec7c333c350207efd45db6bfd92a65f Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Wed, 9 Jan 2019 16:13:04 +0000
Subject: [PATCH 027/137] [libcxx] Remove outdated XFAILs for aligned
 deallocation

AppleClang 10 has been fixed and so these tests don't fail anymore.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350736 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../support.dynamic/libcpp_deallocate.sh.cpp           | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
index 414a75b33..f62e82d8e 100644
--- a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
+++ b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
@@ -14,16 +14,6 @@
 // definitions, which does not yet provide aligned allocation
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// AppleClang 10 (and older) will trigger an availability error when the deployment
-// target does not support aligned allocation, even if we pass `-faligned-allocation`.
-// XFAIL: apple-clang-10 && availability=macosx10.13
-// XFAIL: apple-clang-10 && availability=macosx10.12
-// XFAIL: apple-clang-10 && availability=macosx10.11
-// XFAIL: apple-clang-10 && availability=macosx10.10
-// XFAIL: apple-clang-10 && availability=macosx10.9
-// XFAIL: apple-clang-10 && availability=macosx10.8
-// XFAIL: apple-clang-10 && availability=macosx10.7
-
 // The dylibs shipped before macosx10.14 do not contain the aligned allocation
 // functions, so trying to force using those with -faligned-allocation results
 // in a link error.
-- 
GitLab


From 350f501ab770d7f1dffcb7a125abd7f9e1396a7d Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 9 Jan 2019 16:34:17 +0000
Subject: [PATCH 028/137] Mark two UDL tests as being unsupported with Clang 7

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350739 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../time.cal.day/time.cal.day.nonmembers/literals.pass.cpp      | 2 +-
 .../time.cal.year/time.cal.year.nonmembers/literals.pass.cpp    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
index 765b0e8dc..405200e47 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-5, clang-6
+// UNSUPPORTED: clang-5, clang-6, clang-7
 // UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8, apple-clang-9, apple-clang-10
 
 // <chrono>
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
index 7972e4e94..0661567d8 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-5, clang-6
+// UNSUPPORTED: clang-5, clang-6, clang-7
 // UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8, apple-clang-9, apple-clang-10
 
 // <chrono>
-- 
GitLab


From 504008e535dbb8ed4aa72ccacb524a7288cd5633 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Wed, 9 Jan 2019 16:35:55 +0000
Subject: [PATCH 029/137] [libcxx] Add a script to run CI on MacOS

CI systems like Green Dragon should use this script so as to make
reproducing errors easy locally.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350740 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/ci/macos-trunk.sh | 153 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100755 utils/ci/macos-trunk.sh

diff --git a/utils/ci/macos-trunk.sh b/utils/ci/macos-trunk.sh
new file mode 100755
index 000000000..b365cc6d8
--- /dev/null
+++ b/utils/ci/macos-trunk.sh
@@ -0,0 +1,153 @@
+#!/usr/bin/env bash
+
+set -ue
+
+function usage() {
+  cat <<EOM
+$(basename ${0}) [-h|--help] --libcxx-root <LIBCXX-ROOT> --libcxxabi-root <LIBCXXABI-ROOT> --std <STD> --arch <ARCHITECTURE> [--lit-args <ARGS...>]
+
+This script is used to continually test libc++ and libc++abi trunk on MacOS.
+
+  --libcxx-root     Full path to the root of the libc++ repository to test.
+  --libcxxabi-root  Full path to the root of the libc++abi repository to test.
+  --std             Version of the C++ Standard to run the tests under (c++03, c++11, etc..).
+  --arch            Architecture to build the tests for (32, 64).
+  [--lit-args]      Additional arguments to pass to lit (optional). If there are multiple arguments, quote them to pass them as a single argument to this script.
+  [--no-cleanup]    Do not cleanup the temporary directory that was used for testing at the end. This can be useful to debug failures. Make sure to clean up manually after.
+  [-h, --help]      Print this help.
+EOM
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --libcxx-root)
+    LIBCXX_ROOT="${2}"
+    if [[ ! -e "${LIBCXX_ROOT}" ]]; then
+      echo "--libcxx-root '${LIBCXX_ROOT}' is not a valid directory"
+      usage
+      exit 1
+    fi
+    shift; shift
+    ;;
+    --libcxxabi-root)
+    LIBCXXABI_ROOT="${2}"
+    if [[ ! -e "${LIBCXXABI_ROOT}" ]]; then
+      echo "--libcxxabi-root '${LIBCXXABI_ROOT}' is not a valid directory"
+      usage
+      exit 1
+    fi
+    shift; shift
+    ;;
+    --std)
+    STD="${2}"
+    shift; shift
+    ;;
+    --arch)
+    ARCH="${2}"
+    shift; shift
+    ;;
+    --lit-args)
+    ADDITIONAL_LIT_ARGS="${2}"
+    shift; shift
+    ;;
+    --no-cleanup)
+    NO_CLEANUP=""
+    shift
+    ;;
+    -h|--help)
+    usage
+    exit 0
+    ;;
+    *)
+    echo "${1} is not a supported argument"
+    usage
+    exit 1
+    ;;
+  esac
+done
+
+if [[ -z ${LIBCXX_ROOT+x} ]]; then echo "--libcxx-root is a required parameter"; usage; exit 1; fi
+if [[ -z ${LIBCXXABI_ROOT+x} ]]; then echo "--libcxxabi-root is a required parameter"; usage; exit 1; fi
+if [[ -z ${STD+x} ]]; then echo "--std is a required parameter"; usage; exit 1; fi
+if [[ -z ${ARCH+x} ]]; then echo "--arch is a required parameter"; usage; exit 1; fi
+if [[ -z ${ADDITIONAL_LIT_ARGS+x} ]]; then ADDITIONAL_LIT_ARGS=""; fi
+
+
+TEMP_DIR="$(mktemp -d)"
+echo "Created temporary directory ${TEMP_DIR}"
+function cleanup {
+  if [[ -z ${NO_CLEANUP+x} ]]; then
+    echo "Removing temporary directory ${TEMP_DIR}"
+    rm -rf "${TEMP_DIR}"
+  else
+    echo "Temporary directory is at '${TEMP_DIR}', make sure to clean it up yourself"
+  fi
+}
+trap cleanup EXIT
+
+
+LLVM_ROOT="${TEMP_DIR}/llvm"
+LIBCXX_BUILD_DIR="${TEMP_DIR}/libcxx-build"
+LIBCXX_INSTALL_DIR="${TEMP_DIR}/libcxx-install"
+LIBCXXABI_BUILD_DIR="${TEMP_DIR}/libcxxabi-build"
+LIBCXXABI_INSTALL_DIR="${TEMP_DIR}/libcxxabi-install"
+
+LLVM_TARBALL_URL="https://github.com/llvm-mirror/llvm/archive/master.tar.gz"
+export CC="$(xcrun --find clang)"
+export CXX="$(xcrun --find clang++)"
+
+
+echo "@@@ Downloading LLVM tarball of master (only used for CMake configuration) @@@"
+mkdir "${LLVM_ROOT}"
+curl -L "${LLVM_TARBALL_URL}" | tar -xz --strip-components=1 -C "${LLVM_ROOT}"
+echo "@@@@@@"
+
+
+echo "@@@ Setting up LIT flags @@@"
+LIT_FLAGS="-sv --param=std=${STD} ${ADDITIONAL_LIT_ARGS}"
+if [[ "${ARCH}" == "32" ]]; then
+  LIT_FLAGS+=" --param=enable_32bit=true"
+fi
+echo "@@@@@@"
+
+
+echo "@@@ Configuring CMake for libc++ @@@"
+mkdir -p "${LIBCXX_BUILD_DIR}"
+(cd "${LIBCXX_BUILD_DIR}" &&
+  xcrun cmake "${LIBCXX_ROOT}" -GNinja \
+    -DLLVM_PATH="${LLVM_ROOT}" \
+    -DCMAKE_INSTALL_PREFIX="${LIBCXX_INSTALL_DIR}" \
+    -DLLVM_LIT_ARGS="${LIT_FLAGS}" \
+    -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" # Build a universal dylib
+)
+echo "@@@@@@"
+
+
+echo "@@@ Configuring CMake for libc++abi @@@"
+mkdir -p "${LIBCXXABI_BUILD_DIR}"
+(cd "${LIBCXXABI_BUILD_DIR}" &&
+  xcrun cmake "${LIBCXXABI_ROOT}" -GNinja \
+    -DLIBCXXABI_LIBCXX_PATH="${LIBCXX_ROOT}" \
+    -DLLVM_PATH="${LLVM_ROOT}" \
+    -DCMAKE_INSTALL_PREFIX="${LIBCXXABI_INSTALL_DIR}" \
+    -DLLVM_LIT_ARGS="${LIT_FLAGS}" \
+    -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" # Build a universal dylib
+)
+echo "@@@@@@"
+
+
+echo "@@@ Building libc++.dylib and libc++abi.dylib from sources (just to make sure it works) @@@"
+ninja -C "${LIBCXX_BUILD_DIR}" install-cxx
+ninja -C "${LIBCXXABI_BUILD_DIR}" install-cxxabi
+echo "@@@@@@"
+
+
+echo "@@@ Running tests for libc++ @@@"
+# TODO: We should run check-cxx-abilist too
+ninja -C "${LIBCXX_BUILD_DIR}" check-cxx
+echo "@@@@@@"
+
+
+echo "@@@ Running tests for libc++abi @@@"
+ninja -C "${LIBCXXABI_BUILD_DIR}" check-cxxabi
+echo "@@@@@@"
-- 
GitLab


From 0ef5c2979234d362cb8c1d3f2052f9dc01d4ee96 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Wed, 9 Jan 2019 19:40:20 +0000
Subject: [PATCH 030/137] [libcxx] Add a script to run CI on older MacOS
 versions

This script can be used by CI systems to test things like availability
markup and binary compatibility on older MacOS versions. This is still
a bit rough on the edges, for example we don't test libc++abi yet.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350752 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/ci/macos-backdeployment.sh | 180 +++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100755 utils/ci/macos-backdeployment.sh

diff --git a/utils/ci/macos-backdeployment.sh b/utils/ci/macos-backdeployment.sh
new file mode 100755
index 000000000..1f01fa397
--- /dev/null
+++ b/utils/ci/macos-backdeployment.sh
@@ -0,0 +1,180 @@
+#!/usr/bin/env bash
+
+set -ue
+
+function usage() {
+  cat <<EOM
+$(basename ${0}) [-h|--help] --libcxx-root <LIBCXX-ROOT> --libcxxabi-root <LIBCXXABI-ROOT> --std <STD> --arch <ARCHITECTURE> --deployment-target <TARGET> --sdk-version <SDK-VERSION> [--lit-args <ARGS...>]
+
+This script is used to continually test the back-deployment use case of libc++ and libc++abi on MacOS.
+
+  --libcxx-root       Full path to the root of the libc++ repository to test.
+  --libcxxabi-root    Full path to the root of the libc++abi repository to test.
+  --std               Version of the C++ Standard to run the tests under (c++03, c++11, etc..).
+  --arch              Architecture to build the tests for (32, 64).
+  --deployment-target The deployment target to run the tests for. This should be a version number of MacOS (e.g. 10.12). All MacOS versions until and including 10.7 are supported.
+  --sdk-version       The version of the SDK to test with. This should be a version number of MacOS (e.g. 10.12). We'll link against the libc++ dylib in that SDK, but we'll run against the one on the given deployment target.
+  [--lit-args]        Additional arguments to pass to lit (optional). If there are multiple arguments, quote them to pass them as a single argument to this script.
+  [--no-cleanup]      Do not cleanup the temporary directory that was used for testing at the end. This can be useful to debug failures. Make sure to clean up manually after.
+  [-h, --help]        Print this help.
+EOM
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --libcxx-root)
+    LIBCXX_ROOT="${2}"
+    if [[ ! -d "${LIBCXX_ROOT}" ]]; then
+      echo "--libcxx-root '${LIBCXX_ROOT}' is not a valid directory"
+      usage
+      exit 1
+    fi
+    shift; shift
+    ;;
+    --libcxxabi-root)
+    LIBCXXABI_ROOT="${2}"
+    if [[ ! -d "${LIBCXXABI_ROOT}" ]]; then
+      echo "--libcxxabi-root '${LIBCXXABI_ROOT}' is not a valid directory"
+      usage
+      exit 1
+    fi
+    shift; shift
+    ;;
+    --std)
+    STD="${2}"
+    shift; shift
+    ;;
+    --arch)
+    ARCH="${2}"
+    shift; shift
+    ;;
+    --deployment-target)
+    DEPLOYMENT_TARGET="${2}"
+    shift; shift
+    ;;
+    --sdk-version)
+    MACOS_SDK_VERSION="${2}"
+    shift; shift
+    ;;
+    --lit-args)
+    ADDITIONAL_LIT_ARGS="${2}"
+    shift; shift
+    ;;
+    --no-cleanup)
+    NO_CLEANUP=""
+    shift
+    ;;
+    -h|--help)
+    usage
+    exit 0
+    ;;
+    *)
+    echo "${1} is not a supported argument"
+    usage
+    exit 1
+    ;;
+  esac
+done
+
+if [[ -z ${LIBCXX_ROOT+x} ]]; then echo "--libcxx-root is a required parameter"; usage; exit 1; fi
+if [[ -z ${LIBCXXABI_ROOT+x} ]]; then echo "--libcxxabi-root is a required parameter"; usage; exit 1; fi
+if [[ -z ${STD+x} ]]; then echo "--std is a required parameter"; usage; exit 1; fi
+if [[ -z ${ARCH+x} ]]; then echo "--arch is a required parameter"; usage; exit 1; fi
+if [[ -z ${DEPLOYMENT_TARGET+x} ]]; then echo "--deployment-target is a required parameter"; usage; exit 1; fi
+if [[ -z ${MACOS_SDK_VERSION+x} ]]; then echo "--sdk-version is a required parameter"; usage; exit 1; fi
+if [[ -z ${ADDITIONAL_LIT_ARGS+x} ]]; then ADDITIONAL_LIT_ARGS=""; fi
+
+
+TEMP_DIR="$(mktemp -d)"
+echo "Created temporary directory ${TEMP_DIR}"
+function cleanup {
+  if [[ -z ${NO_CLEANUP+x} ]]; then
+    echo "Removing temporary directory ${TEMP_DIR}"
+    rm -rf "${TEMP_DIR}"
+  else
+    echo "Temporary directory is at '${TEMP_DIR}', make sure to clean it up yourself"
+  fi
+}
+trap cleanup EXIT
+
+
+LLVM_ROOT="${TEMP_DIR}/llvm"
+LIBCXX_BUILD_DIR="${TEMP_DIR}/libcxx-build"
+LIBCXX_INSTALL_DIR="${TEMP_DIR}/libcxx-install"
+LIBCXXABI_BUILD_DIR="${TEMP_DIR}/libcxxabi-build"
+LIBCXXABI_INSTALL_DIR="${TEMP_DIR}/libcxxabi-install"
+
+PREVIOUS_DYLIBS_URL="http://lab.llvm.org:8080/roots/libcxx-roots.tar.gz"
+LLVM_TARBALL_URL="https://github.com/llvm-mirror/llvm/archive/master.tar.gz"
+export CC="$(xcrun --find clang)"
+export CXX="$(xcrun --find clang++)"
+
+
+echo "@@@ Downloading LLVM tarball of master (only used for CMake configuration) @@@"
+mkdir "${LLVM_ROOT}"
+curl -L "${LLVM_TARBALL_URL}" | tar -xz --strip-components=1 -C "${LLVM_ROOT}"
+echo "@@@@@@"
+
+
+echo "@@@ Configuring architecture-related stuff @@@"
+if [[ "${ARCH}" == "64" ]]; then CMAKE_ARCH_STRING="x86_64"; else CMAKE_ARCH_STRING="i386"; fi
+if [[ "${ARCH}" == "64" ]]; then LIT_ARCH_STRING="";         else LIT_ARCH_STRING="--param=enable_32bit=true"; fi
+echo "@@@@@@"
+
+
+echo "@@@ Configuring CMake for libc++ @@@"
+mkdir -p "${LIBCXX_BUILD_DIR}"
+(cd "${LIBCXX_BUILD_DIR}" &&
+  xcrun cmake "${LIBCXX_ROOT}" -GNinja \
+    -DLLVM_PATH="${LLVM_ROOT}" \
+    -DCMAKE_INSTALL_PREFIX="${LIBCXX_INSTALL_DIR}" \
+    -DCMAKE_OSX_ARCHITECTURES="${CMAKE_ARCH_STRING}"
+)
+echo "@@@@@@"
+
+
+echo "@@@ Configuring CMake for libc++abi @@@"
+mkdir -p "${LIBCXXABI_BUILD_DIR}"
+(cd "${LIBCXXABI_BUILD_DIR}" &&
+  xcrun cmake "${LIBCXXABI_ROOT}" -GNinja \
+    -DLIBCXXABI_LIBCXX_PATH="${LIBCXX_ROOT}" \
+    -DLLVM_PATH="${LLVM_ROOT}" \
+    -DCMAKE_INSTALL_PREFIX="${LIBCXXABI_INSTALL_DIR}" \
+    -DCMAKE_OSX_ARCHITECTURES="${CMAKE_ARCH_STRING}"
+)
+echo "@@@@@@"
+
+
+echo "@@@ Installing the latest libc++ headers @@@"
+ninja -C "${LIBCXX_BUILD_DIR}" install-cxx-headers
+echo "@@@@@@"
+
+
+echo "@@@ Downloading dylibs for older deployment targets @@@"
+# TODO: The tarball should contain libc++abi.dylib too, we shouldn't be relying on the system's
+# TODO: We should also link against the libc++abi.dylib that was shipped in the SDK
+PREVIOUS_DYLIBS_DIR="${TEMP_DIR}/libcxx-dylibs"
+mkdir "${PREVIOUS_DYLIBS_DIR}"
+curl "${PREVIOUS_DYLIBS_URL}" | tar -xz --strip-components=1 -C "${PREVIOUS_DYLIBS_DIR}"
+LIBCXX_ON_DEPLOYMENT_TARGET="${PREVIOUS_DYLIBS_DIR}/macOS/${DEPLOYMENT_TARGET}/libc++.dylib"
+LIBCXXABI_ON_DEPLOYMENT_TARGET="/usr/lib/libc++abi.dylib"
+LIBCXX_IN_SDK="${PREVIOUS_DYLIBS_DIR}/macOS/${MACOS_SDK_VERSION}/libc++.dylib"
+echo "@@@@@@"
+
+
+# TODO: We need to also run the tests for libc++abi.
+# TODO: Make sure lit will actually run against the libc++abi we specified
+echo "@@@ Running tests for libc++ @@@"
+"${LIBCXX_BUILD_DIR}/bin/llvm-lit" -sv "${LIBCXX_ROOT}/test" \
+                                   --param=enable_experimental=false \
+                                   --param=enable_filesystem=false \
+                                   ${LIT_ARCH_STRING} \
+                                   --param=cxx_under_test="${CXX}" \
+                                   --param=cxx_headers="${LIBCXX_INSTALL_DIR}/include/c++/v1" \
+                                   --param=std="${STD}" \
+                                   --param=platform="macosx${DEPLOYMENT_TARGET}" \
+                                   --param=cxx_runtime_root="$(dirname "${LIBCXX_ON_DEPLOYMENT_TARGET}")" \
+                                   --param=abi_library_path="$(dirname "${LIBCXXABI_ON_DEPLOYMENT_TARGET}")" \
+                                   --param=use_system_cxx_lib="$(dirname "${LIBCXX_IN_SDK}")" \
+                                   ${ADDITIONAL_LIT_ARGS}
+echo "@@@@@@"
-- 
GitLab


From 668faeab19b6827e5755b747b2b84b6a882a336b Mon Sep 17 00:00:00 2001
From: JF Bastien <jfbastien@apple.com>
Date: Wed, 9 Jan 2019 22:56:45 +0000
Subject: [PATCH 031/137] [NFC] Normalize some test 'main' signatures

There were 3 tests with 'int main(void)', and 6 with the return type on a different line. I'm about to send a patch for main in tests, and this NFC change is unrelated.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350770 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/std/containers/unord/unord.map/compare.pass.cpp           | 3 +--
 .../ostream.inserters.arithmetic/minmax_showbase.pass.cpp      | 2 +-
 .../locale.num.get/facet.num.get.members/test_min_max.pass.cpp | 2 +-
 .../locale.num.get/facet.num.get.members/test_neg_one.pass.cpp | 2 +-
 test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp  | 3 +--
 .../utilities/charconv/charconv.from.chars/integral.pass.cpp   | 3 +--
 .../std/utilities/charconv/charconv.to.chars/integral.pass.cpp | 3 +--
 .../bind/func.bind/func.bind.bind/nested.pass.cpp              | 3 +--
 test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp    | 3 +--
 9 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/test/std/containers/unord/unord.map/compare.pass.cpp b/test/std/containers/unord/unord.map/compare.pass.cpp
index cffc1dbd4..2761bf177 100644
--- a/test/std/containers/unord/unord.map/compare.pass.cpp
+++ b/test/std/containers/unord/unord.map/compare.pass.cpp
@@ -33,8 +33,7 @@ namespace std
     };
 }
 
-int
-main()
+int main()
 {
     typedef std::unordered_map<Key, int> MapT;
     typedef MapT::iterator Iter;
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
index 9e602d4e7..c23b3028c 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
@@ -46,7 +46,7 @@ static void test(std::ios_base::fmtflags fmt, const char *expected)
     assert(ss.str() == expected);
 }
 
-int main(void)
+int main()
 {
     const std::ios_base::fmtflags o = std::ios_base::oct;
     const std::ios_base::fmtflags d = std::ios_base::dec;
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
index e2218fffb..ab02716e3 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
@@ -52,7 +52,7 @@ void check_limits()
     }
 }
 
-int main(void)
+int main()
 {
     check_limits<short>();
     check_limits<unsigned short>();
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
index 712d2897d..bb40f31db 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
@@ -149,7 +149,7 @@ void test_negate() {
     }
 }
 
-int main(void)
+int main()
 {
     test_neg_one<long>();
     test_neg_one<long long>();
diff --git a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
index d9c517230..59673ec88 100644
--- a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
@@ -63,8 +63,7 @@ test4()
     assert((std::regex_match(target, smatch, regex)));
 }
 
-int
-main()
+int main()
 {
     test1();
     test2();
diff --git a/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp b/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
index 4dec67e87..7b08f3047 100644
--- a/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
+++ b/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
@@ -184,8 +184,7 @@ struct test_signed : roundtrip_test_base<T>
     }
 };
 
-int
-main()
+int main()
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
diff --git a/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp b/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
index ddf614e33..63891b1ee 100644
--- a/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
+++ b/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
@@ -82,8 +82,7 @@ struct test_signed : to_chars_test_base<T>
     }
 };
 
-int
-main()
+int main()
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
index 5b660da61..ac43dd769 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
@@ -42,8 +42,7 @@ struct plus_one
   }
 };
 
-int
-main()
+int main()
 {
     using std::placeholders::_1;
 
diff --git a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
index ce6dcf811..977d2b6da 100644
--- a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
@@ -26,8 +26,7 @@ struct X
     void operator()() {}
 };
 
-int
-main()
+int main()
 {
     X x;
     std::function<void()> f(x);
-- 
GitLab


From a131ebfcaf83dc9459976fe42e8070827e721dc8 Mon Sep 17 00:00:00 2001
From: JF Bastien <jfbastien@apple.com>
Date: Wed, 9 Jan 2019 23:20:24 +0000
Subject: [PATCH 032/137] [NFC] Always lock free test: add indirection

I have a big patch coming up, and this indirection is required to avoid hitting the following after my big change:

  error: empty struct has size 0 in C, size 1 in C++ [-Werror,-Wextern-c-compat]

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350772 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
index 7a8d4c1f4..43436e65a 100644
--- a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
@@ -59,7 +59,7 @@ void checkLongLongTypes() {
   static_assert((0 != ATOMIC_LLONG_LOCK_FREE) == ExpectLockFree, "");
 }
 
-int main()
+void run()
 {
 // structs and unions can't be defined in the template invocation.
 // Work around this with a typedef.
@@ -134,3 +134,5 @@ int main()
     static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
     static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
 }
+
+int main() { run(); }
-- 
GitLab


From 4fb9e8f89a5ade3e80def4a5d4d033852901be35 Mon Sep 17 00:00:00 2001
From: JF Bastien <jfbastien@apple.com>
Date: Thu, 10 Jan 2019 18:50:34 +0000
Subject: [PATCH 033/137] Filesystem tests: fix fs.op.relative

Summary: The test wasn't using the testing infrastructure properly.

Reviewers: ldionne, mclow.lists, EricWF

Subscribers: christof, jkorous, dexonsmith, libcxx-commits

Differential Revision: https://reviews.llvm.org/D56519

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350872 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../fs.op.relative/relative.pass.cpp          | 126 ++++++++++++------
 1 file changed, 83 insertions(+), 43 deletions(-)

diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp
index e240c6496..940f886f9 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp
@@ -16,9 +16,8 @@
 // path proximate(const path& p, const path& base, error_code& ec);
 
 #include "filesystem_include.hpp"
+#include <string>
 #include <type_traits>
-#include <vector>
-#include <iostream>
 #include <cassert>
 
 #include "test_macros.h"
@@ -30,49 +29,90 @@
 
 TEST_SUITE(filesystem_proximate_path_test_suite)
 
-TEST_CASE(test_signature) {
+TEST_CASE(test_signature_0) {
+  fs::path p("");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(fs::current_path()));
+}
+
+TEST_CASE(test_signature_1) {
+  fs::path p(".");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(fs::current_path()));
+}
+
+TEST_CASE(test_signature_2) {
+  fs::path p(StaticEnv::File);
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::File));
+}
+
+TEST_CASE(test_signature_3) {
+  fs::path p(StaticEnv::Dir);
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir));
+}
+
+TEST_CASE(test_signature_4) {
+  fs::path p(StaticEnv::SymlinkToDir);
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir));
+}
+
+TEST_CASE(test_signature_5) {
+  fs::path p(StaticEnv::SymlinkToDir / "dir2/.");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2"));
+}
+
+TEST_CASE(test_signature_6) {
+  // FIXME? If the trailing separator occurs in a part of the path that exists,
+  // it is ommitted. Otherwise it is added to the end of the result.
+  fs::path p(StaticEnv::SymlinkToDir / "dir2/./");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2"));
+}
+
+TEST_CASE(test_signature_7) {
+  fs::path p(StaticEnv::SymlinkToDir / "dir2/DNE/./");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir / "dir2/DNE/"));
+}
+
+TEST_CASE(test_signature_8) {
+  fs::path p(StaticEnv::SymlinkToDir / "dir2");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir2));
+}
+
+TEST_CASE(test_signature_9) {
+  fs::path p(StaticEnv::SymlinkToDir / "dir2/../dir2/DNE/..");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir2 / ""));
+}
+
+TEST_CASE(test_signature_10) {
+  fs::path p(StaticEnv::SymlinkToDir / "dir2/dir3/../DNE/DNE2");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir2 / "DNE/DNE2"));
+}
 
+TEST_CASE(test_signature_11) {
+  fs::path p(StaticEnv::Dir / "../dir1");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir));
 }
-int main() {
-  // clang-format off
-  struct {
-    std::string input;
-    std::string expect;
-  } TestCases[] = {
-      {"", fs::current_path()},
-      {".", fs::current_path()},
-      {StaticEnv::File, StaticEnv::File},
-      {StaticEnv::Dir, StaticEnv::Dir},
-      {StaticEnv::SymlinkToDir, StaticEnv::Dir},
-      {StaticEnv::SymlinkToDir / "dir2/.", StaticEnv::Dir / "dir2"},
-      // FIXME? If the trailing separator occurs in a part of the path that exists,
-      // it is ommitted. Otherwise it is added to the end of the result.
-      {StaticEnv::SymlinkToDir / "dir2/./", StaticEnv::Dir / "dir2"},
-      {StaticEnv::SymlinkToDir / "dir2/DNE/./", StaticEnv::Dir / "dir2/DNE/"},
-      {StaticEnv::SymlinkToDir / "dir2", StaticEnv::Dir2},
-      {StaticEnv::SymlinkToDir / "dir2/../dir2/DNE/..", StaticEnv::Dir2 / ""},
-      {StaticEnv::SymlinkToDir / "dir2/dir3/../DNE/DNE2", StaticEnv::Dir2 / "DNE/DNE2"},
-      {StaticEnv::Dir / "../dir1", StaticEnv::Dir},
-      {StaticEnv::Dir / "./.", StaticEnv::Dir},
-      {StaticEnv::Dir / "DNE/../foo", StaticEnv::Dir / "foo"}
-  };
-  // clang-format on
-  int ID = 0;
-  bool Failed = false;
-  for (auto& TC : TestCases) {
-    ++ID;
-    fs::path p(TC.input);
-    const fs::path output = fs::weakly_canonical(p);
-    if (output != TC.expect) {
-      Failed = true;
-      std::cerr << "TEST CASE #" << ID << " FAILED: \n";
-      std::cerr << "  Input: '" << TC.input << "'\n";
-      std::cerr << "  Expected: '" << TC.expect << "'\n";
-      std::cerr << "  Output: '" << output.native() << "'";
-      std::cerr << std::endl;
-    }
-  }
-  return Failed;
+
+TEST_CASE(test_signature_12) {
+  fs::path p(StaticEnv::Dir / "./.");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir));
+}
+
+TEST_CASE(test_signature_13) {
+  fs::path p(StaticEnv::Dir / "DNE/../foo");
+  const fs::path output = fs::weakly_canonical(p);
+  TEST_CHECK(output == std::string(StaticEnv::Dir / "foo"));
 }
 
 TEST_SUITE_END()
-- 
GitLab


From 134a848236518442cc6b4b8006a2927db2e6636b Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Thu, 10 Jan 2019 20:06:11 +0000
Subject: [PATCH 034/137] [libcxx] Reorganize tests since the application of
 P0602R4

Summary:
P0602R4 makes the special member functions of optional and variant
conditionally trivial based on the types in the optional/variant.
We already implemented that, but the tests were organized as if this
were a non-standard extension. This patch reorganizes the tests in a
way that makes more sense since this is not an extension anymore.

Reviewers: EricWF, mpark, mclow.lists

Subscribers: christof, jkorous, dexonsmith, libcxx-commits

Differential Revision: https://reviews.llvm.org/D54772

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350884 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/optional                              |  4 +-
 include/variant                               |  8 +-
 .../optional.object/triviality.abi.pass.cpp}  | 32 +++---
 .../optional.object.assign/copy.pass.cpp      |  6 +-
 .../optional.object.assign/move.pass.cpp      | 38 +++++++-
 .../optional.object.ctor/copy.fail.cpp        | 36 -------
 .../optional.object/special_members.pass.cpp  | 63 ++++++++++++
 .../optional.object/triviality.pass.cpp       | 97 +++++++++++++++++++
 .../variant.assign/copy.pass.cpp              | 32 +++---
 .../variant.assign/move.pass.cpp              | 32 +++---
 .../variant.ctor/copy.pass.cpp                | 28 +++---
 .../variant.ctor/move.pass.cpp                | 28 +++---
 www/cxx2a_status.html                         |  2 +-
 13 files changed, 294 insertions(+), 112 deletions(-)
 rename test/{std/utilities/optional/optional.object/special_member_gen.pass.cpp => libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp} (75%)
 delete mode 100644 test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
 create mode 100644 test/std/utilities/optional/optional.object/special_members.pass.cpp
 create mode 100644 test/std/utilities/optional/optional.object/triviality.pass.cpp

diff --git a/include/optional b/include/optional
index 544140f23..70422068e 100644
--- a/include/optional
+++ b/include/optional
@@ -105,8 +105,8 @@ namespace std {
 
     // 23.6.3.3, assignment
     optional &operator=(nullopt_t) noexcept;
-    optional &operator=(const optional &);
-    optional &operator=(optional &&) noexcept(see below );
+    optional &operator=(const optional &);                // constexpr in C++20
+    optional &operator=(optional &&) noexcept(see below); // constexpr in C++20
     template <class U = T> optional &operator=(U &&);
     template <class U> optional &operator=(const optional<U> &);
     template <class U> optional &operator=(optional<U> &&);
diff --git a/include/variant b/include/variant
index 4a771dc63..a4339de6c 100644
--- a/include/variant
+++ b/include/variant
@@ -23,8 +23,8 @@ namespace std {
 
     // 20.7.2.1, constructors
     constexpr variant() noexcept(see below);
-    variant(const variant&);
-    variant(variant&&) noexcept(see below);
+    variant(const variant&);                // constexpr in C++20
+    variant(variant&&) noexcept(see below); // constexpr in C++20
 
     template <class T> constexpr variant(T&&) noexcept(see below);
 
@@ -46,8 +46,8 @@ namespace std {
     ~variant();
 
     // 20.7.2.3, assignment
-    variant& operator=(const variant&);
-    variant& operator=(variant&&) noexcept(see below);
+    variant& operator=(const variant&);                // constexpr in C++20
+    variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
 
     template <class T> variant& operator=(T&&) noexcept(see below);
 
diff --git a/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp b/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
similarity index 75%
rename from test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
rename to test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
index 0b9b6e717..cdfb02736 100644
--- a/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
@@ -8,8 +8,18 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+
 // <optional>
 
+// This test asserts the triviality of special member functions of optional<T>
+// whenever T has these special member functions trivial. The goal of this test
+// is to make sure that we do not change the triviality of those, since that
+// constitues an ABI break (small enough optionals would be passed by registers).
+//
+// constexpr optional(const optional& rhs);
+// constexpr optional(optional&& rhs) noexcept(see below);
+// constexpr optional<T>& operator=(const optional& rhs);
+// constexpr optional<T>& operator=(optional&& rhs) noexcept(see below);
 
 #include <optional>
 #include <type_traits>
@@ -21,41 +31,27 @@ template <class T>
 struct SpecialMemberTest {
     using O = std::optional<T>;
 
-    static_assert(std::is_default_constructible_v<O>,
-        "optional is always default constructible.");
-    static_assert(std::is_copy_constructible_v<O> == std::is_copy_constructible_v<T>,
-        "optional<T> is copy constructible if and only if T is copy constructible.");
-    static_assert(std::is_move_constructible_v<O> ==
-        (std::is_copy_constructible_v<T> || std::is_move_constructible_v<T>),
-        "optional<T> is move constructible if and only if T is copy or move constructible.");
-    static_assert(std::is_copy_assignable_v<O> ==
-        (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>),
-        "optional<T> is copy assignable if and only if T is both copy "
-        "constructible and copy assignable.");
-    static_assert(std::is_move_assignable_v<O> ==
-        ((std::is_move_constructible_v<T> && std::is_move_assignable_v<T>) ||
-         (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>)),
-        "optional<T> is move assignable if and only if T is both move constructible and "
-        "move assignable, or both copy constructible and copy assignable.");
-
-    // The following tests are for not-yet-standardized behavior (P0602):
     static_assert(std::is_trivially_destructible_v<O> ==
         std::is_trivially_destructible_v<T>,
         "optional<T> is trivially destructible if and only if T is.");
+
     static_assert(std::is_trivially_copy_constructible_v<O> ==
         std::is_trivially_copy_constructible_v<T>,
         "optional<T> is trivially copy constructible if and only if T is.");
+
     static_assert(std::is_trivially_move_constructible_v<O> ==
         std::is_trivially_move_constructible_v<T> ||
         (!std::is_move_constructible_v<T> && std::is_trivially_copy_constructible_v<T>),
         "optional<T> is trivially move constructible if T is trivially move constructible, "
         "or if T is trivially copy constructible and is not move constructible.");
+
     static_assert(std::is_trivially_copy_assignable_v<O> ==
         (std::is_trivially_destructible_v<T> &&
          std::is_trivially_copy_constructible_v<T> &&
          std::is_trivially_copy_assignable_v<T>),
         "optional<T> is trivially copy assignable if and only if T is trivially destructible, "
         "trivially copy constructible, and trivially copy assignable.");
+
     static_assert(std::is_trivially_move_assignable_v<O> ==
         (std::is_trivially_destructible_v<T> &&
          ((std::is_trivially_move_constructible_v<T> && std::is_trivially_move_assignable_v<T>) ||
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
index 98c90aa1d..bec0f09a3 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -10,7 +10,7 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <optional>
 
-// optional<T>& operator=(const optional<T>& rhs);
+// optional<T>& operator=(const optional<T>& rhs); // constexpr in C++20
 
 #include <optional>
 #include <type_traits>
@@ -53,15 +53,19 @@ int main()
 {
     {
         using O = optional<int>;
+#if TEST_STD_VER > 17
         LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
         LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
         assert(assign_empty(O{42}));
         assert(assign_value(O{42}));
     }
     {
         using O = optional<TrivialTestTypes::TestType>;
+#if TEST_STD_VER > 17
         LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
         LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
         assert(assign_empty(O{42}));
         assert(assign_value(O{42}));
     }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
index ed8b433da..c41674f13 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -12,11 +12,12 @@
 
 // optional<T>& operator=(optional<T>&& rhs)
 //     noexcept(is_nothrow_move_assignable<T>::value &&
-//              is_nothrow_move_constructible<T>::value);
+//              is_nothrow_move_constructible<T>::value); // constexpr in C++20
 
 #include <optional>
-#include <type_traits>
 #include <cassert>
+#include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 #include "archetypes.hpp"
@@ -51,6 +52,21 @@ struct Y {};
 bool X::throw_now = false;
 int X::alive = 0;
 
+
+template <class Tp>
+constexpr bool assign_empty(optional<Tp>&& lhs) {
+    optional<Tp> rhs;
+    lhs = std::move(rhs);
+    return !lhs.has_value() && !rhs.has_value();
+}
+
+template <class Tp>
+constexpr bool assign_value(optional<Tp>&& lhs) {
+    optional<Tp> rhs(101);
+    lhs = std::move(rhs);
+    return lhs.has_value() && rhs.has_value() && *lhs == Tp{101};
+}
+
 int main()
 {
     {
@@ -97,6 +113,24 @@ int main()
         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
         assert(*opt == *opt2);
     }
+    {
+        using O = optional<int>;
+#if TEST_STD_VER > 17
+        LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
+        LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
+        assert(assign_empty(O{42}));
+        assert(assign_value(O{42}));
+    }
+    {
+        using O = optional<TrivialTestTypes::TestType>;
+#if TEST_STD_VER > 17
+        LIBCPP_STATIC_ASSERT(assign_empty(O{42}), "");
+        LIBCPP_STATIC_ASSERT(assign_value(O{42}), "");
+#endif
+        assert(assign_empty(O{42}));
+        assert(assign_value(O{42}));
+    }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         static_assert(!std::is_nothrow_move_assignable<optional<X>>::value, "");
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
deleted file mode 100644
index 593368348..000000000
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-// <optional>
-
-// constexpr optional(const optional<T>& rhs);
-//   If is_trivially_copy_constructible_v<T> is true,
-//    this constructor shall be a constexpr constructor.
-
-#include <optional>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-struct S {
-    constexpr S()   : v_(0) {}
-    S(int v)        : v_(v) {}
-    S(const S &rhs) : v_(rhs.v_) {}  // make it not trivially copyable
-    int v_;
-};
-
-
-int main()
-{
-    static_assert (!std::is_trivially_copy_constructible_v<S>, "" );
-    constexpr std::optional<S> o1;
-    constexpr std::optional<S> o2 = o1;  // not constexpr
-}
diff --git a/test/std/utilities/optional/optional.object/special_members.pass.cpp b/test/std/utilities/optional/optional.object/special_members.pass.cpp
new file mode 100644
index 000000000..3bc561cfe
--- /dev/null
+++ b/test/std/utilities/optional/optional.object/special_members.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <optional>
+
+// Make sure we properly generate special member functions for optional<T>
+// based on the properties of T itself.
+
+#include <optional>
+#include <type_traits>
+
+#include "archetypes.hpp"
+
+
+template <class T>
+struct SpecialMemberTest {
+    using O = std::optional<T>;
+
+    static_assert(std::is_default_constructible_v<O>,
+        "optional is always default constructible.");
+
+    static_assert(std::is_copy_constructible_v<O> == std::is_copy_constructible_v<T>,
+        "optional<T> is copy constructible if and only if T is copy constructible.");
+
+    static_assert(std::is_move_constructible_v<O> ==
+        (std::is_copy_constructible_v<T> || std::is_move_constructible_v<T>),
+        "optional<T> is move constructible if and only if T is copy or move constructible.");
+
+    static_assert(std::is_copy_assignable_v<O> ==
+        (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>),
+        "optional<T> is copy assignable if and only if T is both copy "
+        "constructible and copy assignable.");
+
+    static_assert(std::is_move_assignable_v<O> ==
+        ((std::is_move_constructible_v<T> && std::is_move_assignable_v<T>) ||
+         (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>)),
+        "optional<T> is move assignable if and only if T is both move constructible and "
+        "move assignable, or both copy constructible and copy assignable.");
+};
+
+template <class ...Args> static void sink(Args&&...) {}
+
+template <class ...TestTypes>
+struct DoTestsMetafunction {
+    DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
+};
+
+int main() {
+    sink(
+        ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{}
+    );
+}
diff --git a/test/std/utilities/optional/optional.object/triviality.pass.cpp b/test/std/utilities/optional/optional.object/triviality.pass.cpp
new file mode 100644
index 000000000..c21c85aad
--- /dev/null
+++ b/test/std/utilities/optional/optional.object/triviality.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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <optional>
+
+// The following special member functions should propagate the triviality of
+// the element held in the optional (see P0602R4):
+//
+// constexpr optional(const optional& rhs);
+// constexpr optional(optional&& rhs) noexcept(see below);
+// constexpr optional<T>& operator=(const optional& rhs);
+// constexpr optional<T>& operator=(optional&& rhs) noexcept(see below);
+
+
+#include <optional>
+#include <type_traits>
+
+#include "archetypes.hpp"
+
+
+constexpr bool implies(bool p, bool q) {
+    return !p || q;
+}
+
+template <class T>
+struct SpecialMemberTest {
+    using O = std::optional<T>;
+
+    static_assert(implies(std::is_trivially_copy_constructible_v<T>,
+                          std::is_trivially_copy_constructible_v<O>),
+        "optional<T> is trivially copy constructible if T is trivially copy constructible.");
+
+    static_assert(implies(std::is_trivially_move_constructible_v<T>,
+                          std::is_trivially_move_constructible_v<O>),
+        "optional<T> is trivially move constructible if T is trivially move constructible");
+
+    static_assert(implies(std::is_trivially_copy_constructible_v<T> &&
+                          std::is_trivially_copy_assignable_v<T> &&
+                          std::is_trivially_destructible_v<T>,
+
+                          std::is_trivially_copy_assignable_v<O>),
+        "optional<T> is trivially copy assignable if T is "
+        "trivially copy constructible, "
+        "trivially copy assignable, and "
+        "trivially destructible");
+
+    static_assert(implies(std::is_trivially_move_constructible_v<T> &&
+                          std::is_trivially_move_assignable_v<T> &&
+                          std::is_trivially_destructible_v<T>,
+
+                          std::is_trivially_move_assignable_v<O>),
+        "optional<T> is trivially move assignable if T is "
+        "trivially move constructible, "
+        "trivially move assignable, and"
+        "trivially destructible.");
+};
+
+template <class ...Args> static void sink(Args&&...) {}
+
+template <class ...TestTypes>
+struct DoTestsMetafunction {
+    DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
+};
+
+struct TrivialMoveNonTrivialCopy {
+    TrivialMoveNonTrivialCopy() = default;
+    TrivialMoveNonTrivialCopy(const TrivialMoveNonTrivialCopy&) {}
+    TrivialMoveNonTrivialCopy(TrivialMoveNonTrivialCopy&&) = default;
+    TrivialMoveNonTrivialCopy& operator=(const TrivialMoveNonTrivialCopy&) { return *this; }
+    TrivialMoveNonTrivialCopy& operator=(TrivialMoveNonTrivialCopy&&) = default;
+};
+
+struct TrivialCopyNonTrivialMove {
+    TrivialCopyNonTrivialMove() = default;
+    TrivialCopyNonTrivialMove(const TrivialCopyNonTrivialMove&) = default;
+    TrivialCopyNonTrivialMove(TrivialCopyNonTrivialMove&&) {}
+    TrivialCopyNonTrivialMove& operator=(const TrivialCopyNonTrivialMove&) = default;
+    TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
+};
+
+int main() {
+    sink(
+        ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
+        NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
+        DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
+    );
+}
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index 775ecffea..5ea7069f5 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -26,7 +26,7 @@
 
 // template <class ...Types> class variant;
 
-// variant& operator=(variant const&);
+// variant& operator=(variant const&); // constexpr in C++20
 
 #include <cassert>
 #include <string>
@@ -240,7 +240,8 @@ void test_copy_assignment_sfinae() {
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_copy_assignable<V>::value, "");
@@ -262,6 +263,7 @@ void test_copy_assignment_sfinae() {
     using V = std::variant<int, CopyOnly>;
     static_assert(std::is_trivially_copy_assignable<V>::value, "");
   }
+#endif // > C++17
 }
 
 void test_copy_assignment_empty_empty() {
@@ -384,7 +386,8 @@ void test_copy_assignment_same_index() {
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<int> operator()() const {
@@ -441,6 +444,7 @@ void test_copy_assignment_same_index() {
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_copy_assignment_different_index() {
@@ -530,7 +534,8 @@ void test_copy_assignment_different_index() {
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<long> operator()() const {
@@ -559,10 +564,11 @@ void test_copy_assignment_different_index() {
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 template <size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_extension_imp(
+constexpr bool test_constexpr_assign_imp(
     std::variant<long, void*, int>&& v, ValueType&& new_value)
 {
   const std::variant<long, void*, int> cp(
@@ -572,15 +578,17 @@ constexpr bool test_constexpr_assign_extension_imp(
         std::get<NewIdx>(v) == std::get<NewIdx>(cp);
 }
 
-void test_constexpr_copy_assignment_extension() {
-  // The following tests are for not-yet-standardized behavior (P0602):
+void test_constexpr_copy_assignment() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, int>;
   static_assert(std::is_trivially_copyable<V>::value, "");
   static_assert(std::is_trivially_copy_assignable<V>::value, "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
-  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
+  static_assert(test_constexpr_assign_imp<0>(V(42l), 101l), "");
+  static_assert(test_constexpr_assign_imp<0>(V(nullptr), 101l), "");
+  static_assert(test_constexpr_assign_imp<1>(V(42l), nullptr), "");
+  static_assert(test_constexpr_assign_imp<2>(V(42l), 101), "");
+#endif // > C++17
 }
 
 int main() {
@@ -591,5 +599,5 @@ int main() {
   test_copy_assignment_different_index();
   test_copy_assignment_sfinae();
   test_copy_assignment_not_noexcept();
-  test_constexpr_copy_assignment_extension();
+  test_constexpr_copy_assignment();
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index 7b2dedd0d..cee141a8c 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -27,7 +27,7 @@
 
 // template <class ...Types> class variant;
 
-// variant& operator=(variant&&) noexcept(see below);
+// variant& operator=(variant&&) noexcept(see below); // constexpr in C++20
 
 #include <cassert>
 #include <string>
@@ -206,7 +206,8 @@ void test_move_assignment_sfinae() {
     static_assert(!std::is_move_assignable<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_move_assignable<V>::value, "");
@@ -232,6 +233,7 @@ void test_move_assignment_sfinae() {
     using V = std::variant<int, CopyOnly>;
     static_assert(std::is_trivially_move_assignable<V>::value, "");
   }
+#endif // > C++17
 }
 
 void test_move_assignment_empty_empty() {
@@ -353,7 +355,8 @@ void test_move_assignment_same_index() {
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<int> operator()() const {
@@ -396,6 +399,7 @@ void test_move_assignment_same_index() {
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_move_assignment_different_index() {
@@ -445,7 +449,8 @@ void test_move_assignment_different_index() {
   }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<long> operator()() const {
@@ -474,10 +479,11 @@ void test_move_assignment_different_index() {
     static_assert(result.index == 1, "");
     static_assert(result.value == 42, "");
   }
+#endif // > C++17
 }
 
 template <size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_extension_imp(
+constexpr bool test_constexpr_assign_imp(
     std::variant<long, void*, int>&& v, ValueType&& new_value)
 {
   std::variant<long, void*, int> v2(
@@ -488,15 +494,17 @@ constexpr bool test_constexpr_assign_extension_imp(
         std::get<NewIdx>(v) == std::get<NewIdx>(cp);
 }
 
-void test_constexpr_move_assignment_extension() {
-  // The following tests are for not-yet-standardized behavior (P0602):
+void test_constexpr_move_assignment() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, int>;
   static_assert(std::is_trivially_copyable<V>::value, "");
   static_assert(std::is_trivially_move_assignable<V>::value, "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
-  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
+  static_assert(test_constexpr_assign_imp<0>(V(42l), 101l), "");
+  static_assert(test_constexpr_assign_imp<0>(V(nullptr), 101l), "");
+  static_assert(test_constexpr_assign_imp<1>(V(42l), nullptr), "");
+  static_assert(test_constexpr_assign_imp<2>(V(42l), 101), "");
+#endif // > C++17
 }
 
 int main() {
@@ -507,5 +515,5 @@ int main() {
   test_move_assignment_different_index();
   test_move_assignment_sfinae();
   test_move_assignment_noexcept();
-  test_constexpr_move_assignment_extension();
+  test_constexpr_move_assignment();
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index 9e1e77725..6eeec69c8 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -22,7 +22,7 @@
 
 // template <class ...Types> class variant;
 
-// variant(variant const&);
+// variant(variant const&); // constexpr in C++20
 
 #include <cassert>
 #include <type_traits>
@@ -126,7 +126,8 @@ void test_copy_ctor_sfinae() {
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_copy_constructible<V>::value, "");
@@ -144,6 +145,7 @@ void test_copy_ctor_sfinae() {
     using V = std::variant<int, TCopyNTMove>;
     static_assert(std::is_trivially_copy_constructible<V>::value, "");
   }
+#endif // > C++17
 }
 
 void test_copy_ctor_basic() {
@@ -174,7 +176,8 @@ void test_copy_ctor_basic() {
     assert(std::get<1>(v2).value == 42);
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     constexpr std::variant<int> v(std::in_place_index<0>, 42);
     static_assert(v.index() == 0, "");
@@ -217,6 +220,7 @@ void test_copy_ctor_basic() {
     static_assert(v2.index() == 1, "");
     static_assert(std::get<1>(v2).value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_copy_ctor_valueless_by_exception() {
@@ -231,17 +235,16 @@ void test_copy_ctor_valueless_by_exception() {
 }
 
 template <size_t Idx>
-constexpr bool test_constexpr_copy_ctor_extension_imp(
-    std::variant<long, void*, const int> const& v)
-{
+constexpr bool test_constexpr_copy_ctor_imp(std::variant<long, void*, const int> const& v) {
   auto v2 = v;
   return v2.index() == v.index() &&
          v2.index() == Idx &&
          std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
-void test_constexpr_copy_ctor_extension() {
-  // NOTE: This test is for not yet standardized behavior. (P0602)
+void test_constexpr_copy_ctor() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, const int>;
 #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
@@ -252,16 +255,17 @@ void test_constexpr_copy_ctor_extension() {
 #else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
 #endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
-  static_assert(test_constexpr_copy_ctor_extension_imp<0>(V(42l)), "");
-  static_assert(test_constexpr_copy_ctor_extension_imp<1>(V(nullptr)), "");
-  static_assert(test_constexpr_copy_ctor_extension_imp<2>(V(101)), "");
+  static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
+  static_assert(test_constexpr_copy_ctor_imp<1>(V(nullptr)), "");
+  static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
+#endif // > C++17
 }
 
 int main() {
   test_copy_ctor_basic();
   test_copy_ctor_valueless_by_exception();
   test_copy_ctor_sfinae();
-  test_constexpr_copy_ctor_extension();
+  test_constexpr_copy_ctor();
 #if 0
 // disable this for the moment; it fails on older compilers.
 //  Need to figure out which compilers will support it.
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index e6cdb0e96..f59367109 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -22,7 +22,7 @@
 
 // template <class ...Types> class variant;
 
-// variant(variant&&) noexcept(see below);
+// variant(variant&&) noexcept(see below); // constexpr in C++20
 
 #include <cassert>
 #include <string>
@@ -147,7 +147,8 @@ void test_move_ctor_sfinae() {
     static_assert(!std::is_move_constructible<V>::value, "");
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality (see P0602R4).
+#if TEST_STD_VER > 17
   {
     using V = std::variant<int, long>;
     static_assert(std::is_trivially_move_constructible<V>::value, "");
@@ -165,6 +166,7 @@ void test_move_ctor_sfinae() {
     using V = std::variant<int, TMoveNTCopy>;
     static_assert(std::is_trivially_move_constructible<V>::value, "");
   }
+#endif // > C++17
 }
 
 template <typename T>
@@ -214,7 +216,8 @@ void test_move_ctor_basic() {
     assert(std::get<1>(v2).value == 42);
   }
 
-  // The following tests are for not-yet-standardized behavior (P0602):
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   {
     struct {
       constexpr Result<int> operator()() const {
@@ -287,6 +290,7 @@ void test_move_ctor_basic() {
     static_assert(result.index == 1, "");
     static_assert(result.value.value == 42, "");
   }
+#endif // > C++17
 }
 
 void test_move_ctor_valueless_by_exception() {
@@ -300,9 +304,7 @@ void test_move_ctor_valueless_by_exception() {
 }
 
 template <size_t Idx>
-constexpr bool test_constexpr_ctor_extension_imp(
-    std::variant<long, void*, const int> const& v)
-{
+constexpr bool test_constexpr_ctor_imp(std::variant<long, void*, const int> const& v) {
   auto copy = v;
   auto v2 = std::move(copy);
   return v2.index() == v.index() &&
@@ -310,8 +312,9 @@ constexpr bool test_constexpr_ctor_extension_imp(
         std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
-void test_constexpr_move_ctor_extension() {
-  // NOTE: This test is for not yet standardized behavior. (P0602)
+void test_constexpr_move_ctor() {
+  // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
+#if TEST_STD_VER > 17
   using V = std::variant<long, void*, const int>;
 #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
@@ -323,9 +326,10 @@ void test_constexpr_move_ctor_extension() {
   static_assert(std::is_trivially_copyable<V>::value, "");
 #endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_move_constructible<V>::value, "");
-  static_assert(test_constexpr_ctor_extension_imp<0>(V(42l)), "");
-  static_assert(test_constexpr_ctor_extension_imp<1>(V(nullptr)), "");
-  static_assert(test_constexpr_ctor_extension_imp<2>(V(101)), "");
+  static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
+  static_assert(test_constexpr_ctor_imp<1>(V(nullptr)), "");
+  static_assert(test_constexpr_ctor_imp<2>(V(101)), "");
+#endif // > C++17
 }
 
 int main() {
@@ -333,5 +337,5 @@ int main() {
   test_move_ctor_valueless_by_exception();
   test_move_noexcept();
   test_move_ctor_sfinae();
-  test_constexpr_move_ctor_extension();
+  test_constexpr_move_ctor();
 }
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index 63ae029ed..a5e87ec18 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -115,7 +115,7 @@
 	<tr><td><a href="https://wg21.link/P0487R1">P0487R1</a></td><td>LWG</td><td>Fixing operator&gt;&gt;(basic_istream&amp;, CharT*) (LWG 2499)</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
 	<tr><td><a href="https://wg21.link/P0591R4">P0591R4</a></td><td>LWG</td><td>Utility functions to implement uses-allocator construction</td><td>San Diego</td><td><i> </i></td><td></td></tr>
 	<tr><td><a href="https://wg21.link/P0595R2">P0595R2</a></td><td>CWG</td><td>P0595R2 std::is_constant_evaluated()</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-	<tr><td><a href="https://wg21.link/P0602R4">P0602R4</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td><i> </i></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0602R4">P0602R4</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
 	<tr><td><a href="https://wg21.link/P0608R3">P0608R3</a></td><td>LWG</td><td>A sane variant converting constructor</td><td>San Diego</td><td><i> </i></td><td></td></tr>
 	<tr><td><a href="https://wg21.link/P0655R1">P0655R1</a></td><td>LWG</td><td>visit&lt;R&gt;: Explicit Return Type for visit</td><td>San Diego</td><td><i> </i></td><td></td></tr>
 	<tr><td><a href="https://wg21.link/P0771R1">P0771R1</a></td><td>LWG</td><td>std::function move constructor should be noexcept</td><td>San Diego</td><td>Complete</td><td>6.0</td></tr>
-- 
GitLab


From 8d42566e70f025efc5f68bf52cbbbe41981a1e0e Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Fri, 11 Jan 2019 15:12:04 +0000
Subject: [PATCH 035/137] Implement the 'sys_time' portions of the C++20
 calendaring stuff. Reviewed as D56494

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350929 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/chrono                                | 186 +++++++++++++++---
 .../ctor.local_days.pass.cpp                  |  73 +++++++
 .../ctor.sys_days.pass.cpp                    |  73 +++++++
 .../ctor.local_days.pass.cpp                  |  51 ++++-
 .../ctor.sys_days.pass.cpp                    |  54 ++++-
 .../ctor.year_month_day_last.pass.cpp         |  46 ++++-
 .../time.cal.ymd.members/ok.pass.cpp          |  31 +++
 .../op.local_days.pass.cpp                    |  94 +++++++++
 .../time.cal.ymd.members/op.sys_days.pass.cpp |  94 +++++++++
 .../time.cal.ymdlast.members/day.pass.cpp     |  30 +--
 .../op_local_days.pass.cpp                    |  39 +++-
 .../op_sys_days.pass.cpp                      |  39 +++-
 .../ctor.local_days.pass.cpp                  |  65 +++++-
 .../ctor.sys_days.pass.cpp                    |  65 +++++-
 .../ctor.year_month_day_last.pass.cpp         |  41 ----
 .../op.local_days.pass.cpp                    |  74 +++++++
 .../op.sys_days.pass.cpp                      |  74 +++++++
 .../op_local_days.pass.cpp                    |  38 +++-
 .../op_sys_days.pass.cpp                      |  55 ++++--
 .../local_time.types.pass.cpp                 |  65 ++++++
 .../time.clock.system/sys.time.types.pass.cpp |  64 ++++++
 21 files changed, 1209 insertions(+), 142 deletions(-)
 create mode 100644 test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
 create mode 100644 test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
 create mode 100644 test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
 create mode 100644 test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
 delete mode 100644 test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.year_month_day_last.pass.cpp
 create mode 100644 test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
 create mode 100644 test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
 create mode 100644 test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
 create mode 100644 test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp

diff --git a/include/chrono b/include/chrono
index cabf18c03..96759f986 100644
--- a/include/chrono
+++ b/include/chrono
@@ -1592,6 +1592,19 @@ using file_clock = _VSTD_FS::_FilesystemClock;
 template<class _Duration>
 using file_time = time_point<file_clock, _Duration>;
 
+
+template <class _Duration>
+using sys_time    = time_point<system_clock, _Duration>;
+using sys_seconds = sys_time<seconds>;
+using sys_days    = sys_time<days>;
+
+struct local_t {};
+template<class Duration>
+using local_time  = time_point<local_t, Duration>;
+using local_seconds = local_time<seconds>;
+using local_days    = local_time<days>;
+
+
 struct _LIBCPP_TYPE_VIS last_spec { explicit last_spec() = default; };
 
 class _LIBCPP_TYPE_VIS day {
@@ -1812,21 +1825,36 @@ private:
     unsigned char __wd;
 public:
   weekday() = default;
-  explicit inline constexpr weekday(unsigned __val) noexcept: __wd(static_cast<unsigned char>(__val)) {}
-//   inline constexpr weekday(const sys_days& dp) noexcept;
-//   explicit constexpr weekday(const local_days& dp) noexcept;
+  inline explicit constexpr weekday(unsigned __val) noexcept : __wd(static_cast<unsigned char>(__val)) {}
+  inline constexpr          weekday(const sys_days& __sysd) noexcept
+          : __wd(__weekday_from_days(__sysd.time_since_epoch().count())) {}
+  inline explicit constexpr weekday(const local_days& __locd) noexcept
+          : __wd(__weekday_from_days(__locd.time_since_epoch().count())) {}
+
   inline constexpr weekday& operator++()    noexcept { __wd = (__wd == 6 ? 0 : __wd + 1); return *this; }
   inline constexpr weekday  operator++(int) noexcept { weekday __tmp = *this; ++(*this); return __tmp; }
   inline constexpr weekday& operator--()    noexcept { __wd = (__wd == 0 ? 6 : __wd - 1); return *this; }
   inline constexpr weekday  operator--(int) noexcept { weekday __tmp = *this; --(*this); return __tmp; }
          constexpr weekday& operator+=(const days& __dd) noexcept;
          constexpr weekday& operator-=(const days& __dd) noexcept;
-  explicit inline constexpr operator unsigned() const noexcept { return __wd; }
+  inline explicit constexpr operator unsigned() const noexcept { return __wd; }
   inline constexpr bool ok() const noexcept { return __wd <= 6; }
-  constexpr weekday_indexed operator[](unsigned __index) const noexcept;
-  constexpr weekday_last    operator[](last_spec) const noexcept;
+         constexpr weekday_indexed operator[](unsigned __index) const noexcept;
+         constexpr weekday_last    operator[](last_spec) const noexcept;
+
+  static constexpr unsigned char __weekday_from_days(int __days) noexcept;
 };
 
+
+// https://howardhinnant.github.io/date_algorithms.html#weekday_from_days
+inline constexpr
+unsigned char weekday::__weekday_from_days(int __days) noexcept
+{
+    return static_cast<unsigned char>(
+              static_cast<unsigned>(__days >= -4 ? (__days+4) % 7 : (__days+5) % 7 + 6)
+           );
+}
+
 inline constexpr
 bool operator==(const weekday& __lhs, const weekday& __rhs) noexcept
 { return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
@@ -2221,6 +2249,7 @@ constexpr year_month operator-(const year_month& __lhs, const months& __rhs) noe
 constexpr year_month operator-(const year_month& __lhs, const years& __rhs) noexcept
 { return __lhs + -__rhs; }
 
+class year_month_day_last;
 
 class _LIBCPP_TYPE_VIS year_month_day {
 private:
@@ -2232,24 +2261,66 @@ public:
      inline constexpr year_month_day(
             const chrono::year& __yval, const chrono::month& __mval, const chrono::day& __dval) noexcept
             : __y{__yval}, __m{__mval}, __d{__dval} {}  
-//   inline constexpr year_month_day(const year_month_day_last& __ymdl) noexcept;
-//   inline constexpr year_month_day(const sys_days& dp) noexcept;
-//   inline explicit constexpr year_month_day(const local_days& dp) noexcept;
+            constexpr year_month_day(const year_month_day_last& __ymdl) noexcept;
+     inline constexpr year_month_day(const sys_days& __sysd) noexcept
+            : year_month_day(__from_days(__sysd.time_since_epoch())) {}
+     inline explicit constexpr year_month_day(const local_days& __locd) noexcept
+            : year_month_day(__from_days(__locd.time_since_epoch())) {}
+
             constexpr year_month_day& operator+=(const months& __dm) noexcept;
             constexpr year_month_day& operator-=(const months& __dm) noexcept;
             constexpr year_month_day& operator+=(const years& __dy)  noexcept;
             constexpr year_month_day& operator-=(const years& __dy)  noexcept;
-     inline constexpr chrono::year  year()  const noexcept { return __y; }
+
+     inline constexpr chrono::year   year() const noexcept { return __y; }
      inline constexpr chrono::month month() const noexcept { return __m; }
-     inline constexpr chrono::day   day()   const noexcept  { return __d; }
-//   inline constexpr operator            sys_days() const noexcept;
-//   inline explicit constexpr operator local_days() const noexcept;
+     inline constexpr chrono::day     day() const noexcept { return __d; }
+     inline constexpr operator   sys_days() const noexcept          { return   sys_days{__to_days()}; }
+     inline explicit constexpr operator local_days() const noexcept { return local_days{__to_days()}; }
 
-//   TODO: This is not quite correct; requires the calendar bits to do right
-//   d_ is in the range [1d, (y_/m_/last).day()],
-     inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok() && __d.ok(); }
+            constexpr bool             ok() const noexcept;
+
+     static constexpr year_month_day __from_days(days __d) noexcept;
+     constexpr days __to_days() const noexcept;
 };
 
+
+// https://howardhinnant.github.io/date_algorithms.html#civil_from_days
+inline constexpr
+year_month_day
+year_month_day::__from_days(days __d) noexcept
+{
+    static_assert(std::numeric_limits<unsigned>::digits >= 18, "");
+    static_assert(std::numeric_limits<int>::digits >= 20     , "");
+    const int      __z = __d.count() + 719468;
+    const int      __era = (__z >= 0 ? __z : __z - 146096) / 146097;
+    const unsigned __doe = static_cast<unsigned>(__z - __era * 146097);              // [0, 146096]
+    const unsigned __yoe = (__doe - __doe/1460 + __doe/36524 - __doe/146096) / 365;  // [0, 399]
+    const int      __yr = static_cast<int>(__yoe) + __era * 400;
+    const unsigned __doy = __doe - (365 * __yoe + __yoe/4 - __yoe/100);              // [0, 365]
+    const unsigned __mp = (5 * __doy + 2)/153;                                       // [0, 11]
+    const unsigned __dy = __doy - (153 * __mp + 2)/5 + 1;                            // [1, 31]
+    const unsigned __mth = __mp + (__mp < 10 ? 3 : -9);                              // [1, 12]
+    return year_month_day{chrono::year{__yr + (__mth <= 2)}, chrono::month{__mth}, chrono::day{__dy}};
+}
+
+// https://howardhinnant.github.io/date_algorithms.html#days_from_civil
+inline constexpr days year_month_day::__to_days() const noexcept
+{
+    static_assert(std::numeric_limits<unsigned>::digits >= 18, "");
+    static_assert(std::numeric_limits<int>::digits >= 20     , "");
+
+    const int      __yr  = static_cast<int>(__y) - (__m <= February);
+    const unsigned __mth = static_cast<unsigned>(__m);
+    const unsigned __dy  = static_cast<unsigned>(__d);
+
+    const int      __era = (__yr >= 0 ? __yr : __yr - 399) / 400;
+    const unsigned __yoe = static_cast<unsigned>(__yr - __era * 400);                // [0, 399]
+    const unsigned __doy = (153 * (__mth + (__mth > 2 ? -3 : 9)) + 2) / 5 + __dy-1;  // [0, 365]
+    const unsigned __doe = __yoe * 365 + __yoe/4 - __yoe/100 + __doy;                // [0, 146096]
+    return days{__era * 146097 + static_cast<int>(__doe) - 719468};
+}
+
 inline constexpr
 bool operator==(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
 { return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); }
@@ -2347,15 +2418,29 @@ public:
      constexpr year_month_day_last& operator+=(const years& __y)  noexcept;
      constexpr year_month_day_last& operator-=(const years& __y)  noexcept;
 
-     constexpr chrono::year           year()           const noexcept { return __y; }
-     constexpr chrono::month          month()          const noexcept { return __mdl.month(); }
-     constexpr chrono::month_day_last month_day_last() const noexcept { return __mdl; }
-//   constexpr chrono::day            day()            const noexcept;
-//   constexpr          operator sys_days()   const noexcept;
-//   explicit constexpr operator local_days() const noexcept;
-     constexpr bool ok() const noexcept { return __y.ok() && __mdl.ok(); }
+     inline constexpr chrono::year                     year() const noexcept { return __y; }
+     inline constexpr chrono::month                   month() const noexcept { return __mdl.month(); }
+     inline constexpr chrono::month_day_last month_day_last() const noexcept { return __mdl; }
+            constexpr chrono::day                       day() const noexcept;
+     inline constexpr operator                     sys_days() const noexcept { return   sys_days{year()/month()/day()}; }
+     inline explicit constexpr operator          local_days() const noexcept { return local_days{year()/month()/day()}; }
+     inline constexpr bool                               ok() const noexcept { return __y.ok() && __mdl.ok(); }
 };
 
+inline constexpr
+chrono::day year_month_day_last::day() const noexcept
+{
+    constexpr chrono::day __d[] =
+    {
+        chrono::day(31), chrono::day(28), chrono::day(31),
+        chrono::day(30), chrono::day(31), chrono::day(30),
+        chrono::day(31), chrono::day(31), chrono::day(30),
+        chrono::day(31), chrono::day(30), chrono::day(31)
+    };
+    return month() != February || !__y.is_leap() ?
+        __d[static_cast<unsigned>(month()) - 1] : chrono::day{29};
+}
+
 inline constexpr
 bool operator==(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
 { return __lhs.year() == __rhs.year() && __lhs.month_day_last() == __rhs.month_day_last(); }
@@ -2429,6 +2514,15 @@ inline constexpr year_month_day_last& year_month_day_last::operator-=(const mont
 inline constexpr year_month_day_last& year_month_day_last::operator+=(const years& __dy)  noexcept { *this = *this + __dy; return *this; }
 inline constexpr year_month_day_last& year_month_day_last::operator-=(const years& __dy)  noexcept { *this = *this - __dy; return *this; }
 
+inline constexpr year_month_day::year_month_day(const year_month_day_last& __ymdl) noexcept
+    : __y{__ymdl.year()}, __m{__ymdl.month()}, __d{__ymdl.day()} {}  
+
+inline constexpr bool year_month_day::ok() const noexcept
+{
+    if (!__y.ok() || !__m.ok()) return false;
+    return chrono::day{1} <= __d && __d <= (__y / __m / last).day();
+}
+
 class _LIBCPP_TYPE_VIS year_month_weekday {
     chrono::year            __y;
     chrono::month           __m;
@@ -2438,8 +2532,10 @@ public:
     constexpr year_month_weekday(const chrono::year& __yval, const chrono::month& __mval,
                                const chrono::weekday_indexed& __wdival) noexcept
         : __y{__yval}, __m{__mval}, __wdi{__wdival} {}
-//  constexpr year_month_weekday(const sys_days& dp) noexcept;
-//  explicit constexpr year_month_weekday(const local_days& dp) noexcept;
+    constexpr year_month_weekday(const sys_days& __sysd) noexcept
+            : year_month_weekday(__from_days(__sysd.time_since_epoch())) {}
+    inline explicit constexpr year_month_weekday(const local_days& __locd) noexcept
+            : year_month_weekday(__from_days(__locd.time_since_epoch())) {}
     constexpr year_month_weekday& operator+=(const months& m) noexcept;
     constexpr year_month_weekday& operator-=(const months& m) noexcept;
     constexpr year_month_weekday& operator+=(const years& y)  noexcept;
@@ -2451,16 +2547,37 @@ public:
     inline constexpr unsigned                          index() const noexcept { return __wdi.index(); }
     inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi; }
 
-//  constexpr          operator sys_days()   const noexcept;
-//  explicit constexpr operator local_days() const noexcept;
+    inline constexpr                       operator sys_days() const noexcept { return   sys_days{__to_days()}; }
+    inline explicit constexpr operator            local_days() const noexcept { return local_days{__to_days()}; }
     inline constexpr bool ok() const noexcept
     {
         if (!__y.ok() || !__m.ok() || !__wdi.ok()) return false;
     //  TODO: make sure it's a valid date
         return true;
     }
+
+    static constexpr year_month_weekday __from_days(days __d) noexcept;
+    constexpr days __to_days() const noexcept;
 };
 
+inline constexpr
+year_month_weekday year_month_weekday::__from_days(days __d) noexcept
+{
+    const sys_days      __sysd{__d};
+    const chrono::weekday __wd = chrono::weekday(__sysd);
+    const year_month_day __ymd = year_month_day(__sysd);
+    return year_month_weekday{__ymd.year(), __ymd.month(), 
+                              __wd[(static_cast<unsigned>(__ymd.day())-1)/7+1]};
+}
+
+inline constexpr
+days year_month_weekday::__to_days() const noexcept
+{
+    const sys_days __sysd = sys_days(__y/__m/1);
+    return (__sysd + (__wdi.weekday() - chrono::weekday(__sysd) + days{(__wdi.index()-1)*7}))
+                .time_since_epoch();
+}
+
 inline constexpr
 bool operator==(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept
 { return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed(); }
@@ -2538,11 +2655,22 @@ public:
     inline constexpr chrono::month               month() const noexcept { return __m; }
     inline constexpr chrono::weekday           weekday() const noexcept { return __wdl.weekday(); }
     inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl; }
-//  constexpr          operator sys_days()   const noexcept;
-//  explicit constexpr operator local_days() const noexcept;
+    inline constexpr operator                 sys_days() const noexcept { return   sys_days{__to_days()}; }
+    inline explicit constexpr operator      local_days() const noexcept { return local_days{__to_days()}; }
     inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok() && __wdl.ok(); }
+    
+    constexpr days __to_days() const noexcept;
+    
 };
 
+inline constexpr
+days year_month_weekday_last::__to_days() const noexcept
+{
+    const sys_days __last = sys_days{__y/__m/last};
+    return (__last - (chrono::weekday{__last} - __wdl.weekday())).time_since_epoch();
+
+}
+
 inline constexpr
 bool operator==(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept
 { return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last(); }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
new file mode 100644
index 000000000..235138235
--- /dev/null
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class weekday;
+
+//  constexpr weekday(const local_days& dp) noexcept;
+//
+//  Effects:  Constructs an object of type weekday by computing what day
+//              of the week  corresponds to the local_days dp, and representing
+//              that day of the week in wd_ 
+//
+//  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
+//                ymd == year_month_day{sys_days{ymd}} is true.
+// 
+// [Example: 
+//  If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_.
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using local_days = std::chrono::local_days;
+    using days       = std::chrono::days;
+    using weekday    = std::chrono::weekday;
+
+    ASSERT_NOEXCEPT(weekday{std::declval<local_days>()});
+
+    {
+    constexpr local_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 4, "");
+    }
+
+    {
+    constexpr local_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 3, "");
+    }
+
+
+    {
+    constexpr local_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 2, "");
+    }
+
+    {
+    local_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    weekday wd{sd};
+
+    assert( wd.ok());
+    assert(static_cast<unsigned>(wd) == 3);
+    }
+}
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
new file mode 100644
index 000000000..c49d05d3a
--- /dev/null
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class weekday;
+
+//  constexpr weekday(const sys_days& dp) noexcept;
+//
+//  Effects:  Constructs an object of type weekday by computing what day
+//              of the week  corresponds to the sys_days dp, and representing
+//              that day of the week in wd_ 
+//
+//  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
+//                ymd == year_month_day{sys_days{ymd}} is true.
+// 
+// [Example: 
+//  If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_.
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using sys_days  = std::chrono::sys_days;
+    using days      = std::chrono::days;
+    using weekday   = std::chrono::weekday;
+
+    ASSERT_NOEXCEPT(weekday{std::declval<sys_days>()});
+
+    {
+    constexpr sys_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 4, "");
+    }
+
+    {
+    constexpr sys_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 3, "");
+    }
+
+
+    {
+    constexpr sys_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 2, "");
+    }
+
+    {
+    sys_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    weekday wd{sd};
+
+    assert( wd.ok());
+    assert(static_cast<unsigned>(wd) == 3);
+    }
+}
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
index f3321d508..5c7de1418 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day;
@@ -34,11 +33,53 @@
 int main()
 {
     using year           = std::chrono::year;
-    using month          = std::chrono::month;
     using day            = std::chrono::day;
-//  using local_days     = std::chrono::local_days;
+    using local_days     = std::chrono::local_days;
+    using days           = std::chrono::days;
     using year_month_day = std::chrono::year_month_day;
 
-//  ASSERT_NOEXCEPT(year_month_day{std::declval<const local_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_day{std::declval<local_days>()});
+
+    {
+    constexpr local_days sd{};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1970},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{1},               "");
+    }
+
+    {
+    constexpr local_days sd{days{10957+32}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                             "");
+    static_assert( ymd.year()  == year{2000},            "");
+    static_assert( ymd.month() == std::chrono::February, "");
+    static_assert( ymd.day()   == day{2},                "");
+    }
+
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr local_days sd{days{-10957}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1940},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{2},               "");
+    }
+
+    {
+    local_days sd{days{-(10957+34)}};
+    year_month_day ymd{sd};
+
+    assert( ymd.ok());
+    assert( ymd.year()  == year{1939});
+    assert( ymd.month() == std::chrono::November);
+    assert( ymd.day()   == day{29});
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
index d2e268d7d..36a6c7d18 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
@@ -7,15 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day;
 
 //  constexpr year_month_day(const sys_days& dp) noexcept;
 //
-//  Effects:  Constructs an object of type year_month_day that corresponds
-//                to the date represented by dp
+//  Effects:  Constructs an object of type year_month_day that corresponds 
+//                to the date represented by dp.
 //
 //  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
 //                ymd == year_month_day{sys_days{ymd}} is true.
@@ -33,12 +32,53 @@
 int main()
 {
     using year           = std::chrono::year;
-    using month          = std::chrono::month;
     using day            = std::chrono::day;
-//  using sys_days     = std::chrono::sys_days;
+    using sys_days       = std::chrono::sys_days;
+    using days           = std::chrono::days;
     using year_month_day = std::chrono::year_month_day;
 
-//  ASSERT_NOEXCEPT(year_month_day{std::declval<const sys_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_day{std::declval<sys_days>()});
 
+    {
+    constexpr sys_days sd{};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1970},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{1},               "");
+    }
+
+    {
+    constexpr sys_days sd{days{10957+32}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                             "");
+    static_assert( ymd.year()  == year{2000},            "");
+    static_assert( ymd.month() == std::chrono::February, "");
+    static_assert( ymd.day()   == day{2},                "");
+    }
+
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr sys_days sd{days{-10957}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1940},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{2},               "");
+    }
+
+    {
+    sys_days sd{days{-(10957+34)}};
+    year_month_day ymd{sd};
+
+    assert( ymd.ok());
+    assert( ymd.year()  == year{1939});
+    assert( ymd.month() == std::chrono::November);
+    assert( ymd.day()   == day{29});
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
index 2b5fbab1a..a8d6526b3 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day;
@@ -33,10 +32,49 @@ int main()
     using year                = std::chrono::year;
     using month               = std::chrono::month;
     using day                 = std::chrono::day;
-//  using year_month_day_last = std::chrono::year_month_day_last;
+    using month_day_last = std::chrono::month_day_last;
+    using year_month_day_last = std::chrono::year_month_day_last;
     using year_month_day      = std::chrono::year_month_day;
 
-//  ASSERT_NOEXCEPT(year_month_day{std::declval<const year_month_day_last>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_day{std::declval<const year_month_day_last>()});
 
+    {
+    constexpr year_month_day_last ymdl{year{2019}, month_day_last{month{1}}};
+    constexpr year_month_day ymd{ymdl};
+
+    static_assert( ymd.year()  == year{2019}, "");
+    static_assert( ymd.month() == month{1},   "");
+    static_assert( ymd.day()   == day{31},    "");
+    static_assert( ymd.ok(),                  "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{month{4}}};
+    constexpr year_month_day ymd{ymdl};
+
+    static_assert( ymd.year()  == year{1970}, "");
+    static_assert( ymd.month() == month{4},   "");
+    static_assert( ymd.day()   == day{30},    "");
+    static_assert( ymd.ok(),                  "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{month{2}}};
+    constexpr year_month_day ymd{ymdl};
+
+    static_assert( ymd.year()  == year{2000}, "");
+    static_assert( ymd.month() == month{2},   "");
+    static_assert( ymd.day()   == day{29},    "");
+    static_assert( ymd.ok(),                  "");
+    }
+
+    { // Feb 1900 was NOT a leap year.
+    year_month_day_last ymdl{year{1900}, month_day_last{month{2}}};
+    year_month_day ymd{ymdl};
+
+    assert( ymd.year()  == year{1900});
+    assert( ymd.month() == month{2});
+    assert( ymd.day()   == day{28});
+    assert( ymd.ok());
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
index 529d0d760..cab0599b9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
@@ -44,6 +44,37 @@ int main()
 
     static_assert( year_month_day{year{2019},   January, day{1}}.ok(), ""); // All OK
 
+//  Some months have a 31st
+    static_assert( year_month_day{year{2020},   month{ 1}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 2}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 3}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 4}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 5}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 6}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 7}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 8}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 9}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{10}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{11}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{12}, day{31}}.ok(), "");
+
+//  Everyone except FEB has a 30th
+    static_assert( year_month_day{year{2020},   month{ 1}, day{30}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 2}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 3}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 4}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 5}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 6}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 7}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 8}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 9}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{10}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{11}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{12}, day{30}}.ok(), "");
+
+    static_assert(!year_month_day{year{2019},   std::chrono::February, day{29}}.ok(), ""); // Not a leap year
+    static_assert( year_month_day{year{2020},   std::chrono::February, day{29}}.ok(), ""); // Ok; 2020 is a leap year
+
     for (unsigned i = 0; i <= 50; ++i)
     {
         year_month_day ym{year{2019}, January, day{i}};
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
new file mode 100644
index 000000000..720a1c800
--- /dev/null
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_day;
+
+// constexpr operator local_days() const noexcept;
+//
+// Returns: If ok(), returns a local_days holding a count of days from the
+//   local_days epoch to *this (a negative value if *this represents a date
+//   prior to the sys_days epoch). Otherwise, if y_.ok() && m_.ok() is true,
+//   returns a sys_days which is offset from sys_days{y_/m_/last} by the
+//   number of days d_ is offset from sys_days{y_/m_/last}.day(). Otherwise
+//   the value returned is unspecified.
+//
+// Remarks: A local_days in the range [days{-12687428}, days{11248737}] which
+//   is converted to a year_month_day shall have the same value when
+//   converted back to a sys_days.
+//
+// [Example:
+//   static_assert(year_month_day{local_days{2017y/January/0}}  == 2016y/December/31);
+//   static_assert(year_month_day{local_days{2017y/January/31}} == 2017y/January/31);
+//   static_assert(year_month_day{local_days{2017y/January/32}} == 2017y/February/1);
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+void RunTheExample()
+{
+    using namespace std::chrono;
+
+    static_assert(year_month_day{local_days{2017y/January/0}}  == 2016y/December/31);
+    static_assert(year_month_day{local_days{2017y/January/31}} == 2017y/January/31);
+    static_assert(year_month_day{local_days{2017y/January/32}} == 2017y/February/1);  
+}
+
+int main()
+{
+    using year           = std::chrono::year;
+    using month          = std::chrono::month;
+    using day            = std::chrono::day;
+    using local_days       = std::chrono::local_days;
+    using days           = std::chrono::days;
+    using year_month_day = std::chrono::year_month_day;
+
+    ASSERT_NOEXCEPT(local_days(std::declval<year_month_day>()));
+    RunTheExample();
+
+    {
+    constexpr year_month_day ymd{year{1970}, month{1}, day{1}};
+    constexpr local_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    constexpr year_month_day ymd{year{2000}, month{2}, day{2}};
+    constexpr local_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_day ymd{year{1940}, month{1}, day{2}};
+    constexpr local_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    year_month_day ymd{year{1939}, month{11}, day{29}};
+    local_days sd{ymd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_day{sd} == ymd); // and back
+    }
+
+}
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
new file mode 100644
index 000000000..da9865d9c
--- /dev/null
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_day;
+
+// constexpr operator sys_days() const noexcept;
+//
+// Returns: If ok(), returns a sys_days holding a count of days from the
+//   sys_days epoch to *this (a negative value if *this represents a date
+//   prior to the sys_days epoch). Otherwise, if y_.ok() && m_.ok() is true,
+//   returns a sys_days which is offset from sys_days{y_/m_/last} by the
+//   number of days d_ is offset from sys_days{y_/m_/last}.day(). Otherwise
+//   the value returned is unspecified.
+//
+// Remarks: A sys_days in the range [days{-12687428}, days{11248737}] which
+//   is converted to a year_month_day shall have the same value when
+//   converted back to a sys_days.
+//
+// [Example:
+//   static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
+//   static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
+//   static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+void RunTheExample()
+{
+    using namespace std::chrono;
+
+    static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
+    static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
+    static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);  
+}
+
+int main()
+{
+    using year           = std::chrono::year;
+    using month          = std::chrono::month;
+    using day            = std::chrono::day;
+    using sys_days       = std::chrono::sys_days;
+    using days           = std::chrono::days;
+    using year_month_day = std::chrono::year_month_day;
+
+    ASSERT_NOEXCEPT(sys_days(std::declval<year_month_day>()));
+    RunTheExample();
+
+    {
+    constexpr year_month_day ymd{year{1970}, month{1}, day{1}};
+    constexpr sys_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    constexpr year_month_day ymd{year{2000}, month{2}, day{2}};
+    constexpr sys_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_day ymd{year{1940}, month{1}, day{2}};
+    constexpr sys_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    year_month_day ymd{year{1939}, month{11}, day{29}};
+    sys_days sd{ymd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_day{sd} == ymd); // and back
+    }
+
+}
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
index f68e3239f..db3369c6c 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -29,15 +28,24 @@ int main()
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
 
-//  TODO: wait for calendar
-//     ASSERT_NOEXCEPT(               std::declval<const year_month_day_last>().day());
-//     ASSERT_SAME_TYPE(day, decltype(std::declval<const year_month_day_last>().day()));
-//
-//     static_assert( year_month_day_last{}.day() == day{}, "");
+    ASSERT_NOEXCEPT(               std::declval<const year_month_day_last>().day());
+    ASSERT_SAME_TYPE(day, decltype(std::declval<const year_month_day_last>().day()));
+
+//  Some months have a 31st
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 1}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 2}}}.day() == day{29}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 3}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 4}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 5}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 6}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 7}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 8}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 9}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{10}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{11}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{12}}}.day() == day{31}, "");
 
-    for (unsigned i = 1; i <= 12; ++i)
-    {
-        year_month_day_last ymd(year{1234}, month_day_last{month{i}});
-        assert( static_cast<unsigned>(ymd.day()) == i);
-    }
+    assert((year_month_day_last{year{2019}, month_day_last{month{ 2}}}.day() == day{28}));
+    assert((year_month_day_last{year{2020}, month_day_last{month{ 2}}}.day() == day{29}));
+    assert((year_month_day_last{year{2021}, month_day_last{month{ 2}}}.day() == day{28}));
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
index 43a3ef203..45f1ac4ae 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -24,13 +23,39 @@
 int main()
 {
     using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
-//  using sys_days            = std::chrono::local_days;
+    using local_days          = std::chrono::local_days;
+    using days                = std::chrono::days;
 
-//  ASSERT_NOEXCEPT(                static_cast<local_days>(std::declval<const year_month_day_last>().year()));
-//  ASSERT_SAME_TYPE(year, decltype(static_cast<local_days>(std::declval<const year_month_day_last>().year()));
-    assert(false);
+    ASSERT_NOEXCEPT(                      static_cast<local_days>(std::declval<const year_month_day_last>()));
+    ASSERT_SAME_TYPE(local_days, decltype(static_cast<local_days>(std::declval<const year_month_day_last>())));
+
+    { // Last day in Jan 1970 was the 31st
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+    
+    static_assert(sd.time_since_epoch() == days{30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{10957+30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1940}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{-10957+29}, "");
+    }
+
+    {
+    year_month_day_last ymdl{year{1939}, month_day_last{std::chrono::November}};
+    local_days sd{ymdl};
+
+    assert(sd.time_since_epoch() == days{-(10957+33)});
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
index 8c1b3131e..20aff6d1d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -24,13 +23,39 @@
 int main()
 {
     using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
-//  using sys_days            = std::chrono::sys_days;
+    using sys_days            = std::chrono::sys_days;
+    using days                = std::chrono::days;
 
-//  ASSERT_NOEXCEPT(                static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
-//  ASSERT_SAME_TYPE(year, decltype(static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
-    assert(false);
+    ASSERT_NOEXCEPT(                    static_cast<sys_days>(std::declval<const year_month_day_last>()));
+    ASSERT_SAME_TYPE(sys_days, decltype(static_cast<sys_days>(std::declval<const year_month_day_last>())));
+
+    { // Last day in Jan 1970 was the 31st
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{std::chrono::January}};
+    constexpr sys_days sd{ymdl};
+    
+    static_assert(sd.time_since_epoch() == days{30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{std::chrono::January}};
+    constexpr sys_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{10957+30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1940}, month_day_last{std::chrono::January}};
+    constexpr sys_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{-10957+29}, "");
+    }
+
+    {
+    year_month_day_last ymdl{year{1939}, month_day_last{std::chrono::November}};
+    sys_days sd{ymdl};
+
+    assert(sd.time_since_epoch() == days{-(10957+33)});
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
index dbc3c855a..a0b98abb7 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_weekday;
@@ -33,12 +32,64 @@
 
 int main()
 {
-    using year           = std::chrono::year;
-    using month          = std::chrono::month;
-    using day            = std::chrono::day;
-//  using local_days     = std::chrono::local_days;
+    using year               = std::chrono::year;
+    using days               = std::chrono::days;
+    using local_days         = std::chrono::local_days;
+    using weekday_indexed    = std::chrono::weekday_indexed;
     using year_month_weekday = std::chrono::year_month_weekday;
 
-//  ASSERT_NOEXCEPT(year_month_weekday{std::declval<const local_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_weekday{std::declval<const local_days>()});
+
+    {
+    constexpr local_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1970},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Thursday,                      "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Thursday, 1},  "");
+    static_assert( ymwd                   == year_month_weekday{local_days{ymwd}},       ""); // round trip
+    }
+
+    {
+    constexpr local_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{2000},                                 "");
+    static_assert( ymwd.month()           == std::chrono::February,                      "");
+    static_assert( ymwd.weekday()         == std::chrono::Wednesday,                     "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 1}, "");
+    static_assert( ymwd                   == year_month_weekday{local_days{ymwd}},       ""); // round trip
+    }
+
+
+    {
+    constexpr local_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1940},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Tuesday,                       "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Tuesday, 1},   "");
+    static_assert( ymwd                   == year_month_weekday{local_days{ymwd}},       ""); // round trip
+    }
+
+    {
+    local_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    year_month_weekday ymwd{sd};
+
+    assert( ymwd.ok());
+    assert( ymwd.year()            == year{1939});
+    assert( ymwd.month()           == std::chrono::November);
+    assert( ymwd.weekday()         == std::chrono::Wednesday);
+    assert( ymwd.index()           == 5);
+    assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
+    assert( ymwd                   == year_month_weekday{local_days{ymwd}}); // round trip
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
index 52b3f712f..b9d3b6c62 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_weekday;
@@ -32,12 +31,64 @@
 
 int main()
 {
-    using year           = std::chrono::year;
-    using month          = std::chrono::month;
-    using day            = std::chrono::day;
-//  using sys_days     = std::chrono::sys_days;
+    using year               = std::chrono::year;
+    using days               = std::chrono::days;
+    using sys_days           = std::chrono::sys_days;
+    using weekday_indexed    = std::chrono::weekday_indexed;
     using year_month_weekday = std::chrono::year_month_weekday;
 
-//  ASSERT_NOEXCEPT(year_month_weekday{std::declval<const sys_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_weekday{std::declval<const sys_days>()});
+
+    {
+    constexpr sys_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1970},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Thursday,                      "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Thursday, 1},  "");
+    static_assert( ymwd                   == year_month_weekday{sys_days{ymwd}},         ""); // round trip
+    }
+
+    {
+    constexpr sys_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{2000},                                 "");
+    static_assert( ymwd.month()           == std::chrono::February,                      "");
+    static_assert( ymwd.weekday()         == std::chrono::Wednesday,                     "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 1}, "");
+    static_assert( ymwd                   == year_month_weekday{sys_days{ymwd}},         ""); // round trip
+    }
+
+
+    {
+    constexpr sys_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1940},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Tuesday,                       "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Tuesday, 1},   "");
+    static_assert( ymwd                   == year_month_weekday{sys_days{ymwd}},         ""); // round trip
+    }
+
+    {
+    sys_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    year_month_weekday ymwd{sd};
+
+    assert( ymwd.ok());
+    assert( ymwd.year()            == year{1939});
+    assert( ymwd.month()           == std::chrono::November);
+    assert( ymwd.weekday()         == std::chrono::Wednesday);
+    assert( ymwd.index()           == 5);
+    assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
+    assert( ymwd                   == year_month_weekday{sys_days{ymwd}}); // round trip
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.year_month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.year_month_day_last.pass.cpp
deleted file mode 100644
index b873a1956..000000000
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.year_month_day_last.pass.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year_month_weekday;
-
-//  constexpr year_month_weekday(const year_month_weekday_last& ymdl) noexcept;
-//
-//  Effects:  Constructs an object of type year_month_weekday by initializing
-//              y_ with ymdl.year(), m_ with ymdl.month(), and d_ with ymdl.day().
-//
-//  constexpr chrono::year   year() const noexcept;
-//  constexpr chrono::month month() const noexcept;
-//  constexpr chrono::day     day() const noexcept;
-//  constexpr bool             ok() const noexcept;
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main()
-{
-    using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
-    using year_month_weekday_last = std::chrono::year_month_weekday_last;
-    using year_month_weekday      = std::chrono::year_month_weekday;
-
-    ASSERT_NOEXCEPT(year_month_weekday{std::declval<const year_month_weekday_last>()});
-
-}
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
new file mode 100644
index 000000000..ef30ce526
--- /dev/null
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_weekday;
+
+// explicit constexpr operator local_days() const noexcept;
+//
+// Returns: If y_.ok() && m_.ok() && wdi_.weekday().ok(), returns a
+//    sys_days that represents the date (index() - 1) * 7 days after the first
+//    weekday() of year()/month(). If index() is 0 the returned sys_days
+//    represents the date 7 days prior to the first weekday() of
+//    year()/month(). Otherwise the returned value is unspecified.
+//
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using year               = std::chrono::year;
+    using month              = std::chrono::month;
+    using weekday_indexed    = std::chrono::weekday_indexed;
+    using local_days         = std::chrono::local_days;
+    using days               = std::chrono::days;
+    using year_month_weekday = std::chrono::year_month_weekday;
+
+    ASSERT_NOEXCEPT(local_days(std::declval<year_month_weekday>()));
+
+    {
+    constexpr year_month_weekday ymwd{year{1970}, month{1}, weekday_indexed{std::chrono::Thursday, 1}};
+    constexpr local_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    constexpr year_month_weekday ymwd{year{2000}, month{2}, weekday_indexed{std::chrono::Wednesday, 1}};
+    constexpr local_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_weekday ymwd{year{1940}, month{1},weekday_indexed{std::chrono::Tuesday, 1}};
+    constexpr local_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    year_month_weekday ymwd{year{1939}, month{11}, weekday_indexed{std::chrono::Wednesday, 5}};
+    local_days sd{ymwd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_weekday{sd} == ymwd); // and back
+    }
+
+}
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
new file mode 100644
index 000000000..04986e50d
--- /dev/null
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_weekday;
+
+// constexpr operator sys_days() const noexcept;
+//
+// Returns: If y_.ok() && m_.ok() && wdi_.weekday().ok(), returns a
+//    sys_days that represents the date (index() - 1) * 7 days after the first
+//    weekday() of year()/month(). If index() is 0 the returned sys_days
+//    represents the date 7 days prior to the first weekday() of
+//    year()/month(). Otherwise the returned value is unspecified.
+//
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using year               = std::chrono::year;
+    using month              = std::chrono::month;
+    using weekday_indexed    = std::chrono::weekday_indexed;
+    using sys_days           = std::chrono::sys_days;
+    using days               = std::chrono::days;
+    using year_month_weekday = std::chrono::year_month_weekday;
+
+    ASSERT_NOEXCEPT(sys_days(std::declval<year_month_weekday>()));
+
+    {
+    constexpr year_month_weekday ymwd{year{1970}, month{1}, weekday_indexed{std::chrono::Thursday, 1}};
+    constexpr sys_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    constexpr year_month_weekday ymwd{year{2000}, month{2}, weekday_indexed{std::chrono::Wednesday, 1}};
+    constexpr sys_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_weekday ymwd{year{1940}, month{1},weekday_indexed{std::chrono::Tuesday, 1}};
+    constexpr sys_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    year_month_weekday ymwd{year{1939}, month{11}, weekday_indexed{std::chrono::Wednesday, 5}};
+    sys_days sd{ymwd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_weekday{sd} == ymwd); // and back
+    }
+
+}
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
index 56009c422..45f1ac4ae 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -24,12 +23,39 @@
 int main()
 {
     using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
-    using sys_days            = std::chrono::local_days;
+    using local_days          = std::chrono::local_days;
+    using days                = std::chrono::days;
 
-    ASSERT_NOEXCEPT(                static_cast<local_days>(std::declval<const year_month_day_last>().year()));
-    ASSERT_SAME_TYPE(year, decltype(static_cast<local_days>(std::declval<const year_month_day_last>().year()));
+    ASSERT_NOEXCEPT(                      static_cast<local_days>(std::declval<const year_month_day_last>()));
+    ASSERT_SAME_TYPE(local_days, decltype(static_cast<local_days>(std::declval<const year_month_day_last>())));
+
+    { // Last day in Jan 1970 was the 31st
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+    
+    static_assert(sd.time_since_epoch() == days{30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{10957+30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1940}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{-10957+29}, "");
+    }
+
+    {
+    year_month_day_last ymdl{year{1939}, month_day_last{std::chrono::November}};
+    local_days sd{ymdl};
+
+    assert(sd.time_since_epoch() == days{-(10957+33)});
+    }
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
index 47beca7d9..c5abe4ace 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
@@ -7,13 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
-// class year_month_day_last;
+// class year_month_weekday_last;
 
 // constexpr operator sys_days() const noexcept;
-//  Returns: sys_days{year()/month()/day()}.
+//  Returns: If ok() == true, returns a sys_days that represents the last weekday() 
+//             of year()/month(). Otherwise the returned value is unspecified.
 
 #include <chrono>
 #include <type_traits>
@@ -21,16 +21,49 @@
 
 #include "test_macros.h"
 
+#include <iostream>
+
 int main()
 {
-    using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
-    using month_day_last      = std::chrono::month_day_last;
-    using year_month_day_last = std::chrono::year_month_day_last;
-    using sys_days            = std::chrono::sys_days;
+    using year                    = std::chrono::year;
+    using month                   = std::chrono::month;
+    using year_month_weekday_last = std::chrono::year_month_weekday_last;
+    using sys_days                = std::chrono::sys_days;
+    using days                    = std::chrono::days;
+    using weekday                 = std::chrono::weekday;
+    using weekday_last            = std::chrono::weekday_last;
+
+    ASSERT_NOEXCEPT(                    static_cast<sys_days>(std::declval<const year_month_weekday_last>()));
+    ASSERT_SAME_TYPE(sys_days, decltype(static_cast<sys_days>(std::declval<const year_month_weekday_last>())));
+
+    constexpr month   January = std::chrono::January;
+    constexpr weekday Tuesday = std::chrono::Tuesday;
+
+    { // Last Tuesday in Jan 1970 was the 27th
+    constexpr year_month_weekday_last ymwdl{year{1970}, January, weekday_last{Tuesday}};
+    constexpr sys_days sd{ymwdl};
+    
+    static_assert(sd.time_since_epoch() == days{26}, "");
+    }
+
+    { // Last Tuesday in Jan 2000 was the 25th
+    constexpr year_month_weekday_last ymwdl{year{2000}, January, weekday_last{Tuesday}};
+    constexpr sys_days sd{ymwdl};
+    
+    static_assert(sd.time_since_epoch() == days{10957+24}, "");
+    }
+
+    { // Last Tuesday in Jan 1940 was the 30th
+    constexpr year_month_weekday_last ymwdl{year{1940}, January, weekday_last{Tuesday}};
+    constexpr sys_days sd{ymwdl};
+    
+    static_assert(sd.time_since_epoch() == days{-10958+29}, "");
+    }
 
-    ASSERT_NOEXCEPT(                static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
-    ASSERT_SAME_TYPE(year, decltype(static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
+    { // Last Tuesday in Nov 1939 was the 28th
+    year_month_weekday_last ymdl{year{1939}, std::chrono::November, weekday_last{Tuesday}};
+    sys_days sd{ymdl};
 
+    assert(sd.time_since_epoch() == days{-(10957+35)});
+    }
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
new file mode 100644
index 000000000..9f91ca744
--- /dev/null
+++ b/test/std/utilities/time/time.clock/time.clock.system/local_time.types.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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+
+// struct local_t {};
+// template<class Duration>
+//   using local_time  = time_point<system_clock, Duration>;
+// using local_seconds = sys_time<seconds>;
+// using local_days    = sys_time<days>;
+
+// [Example: 
+//   sys_seconds{sys_days{1970y/January/1}}.time_since_epoch() is 0s. 
+//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946’684’800s, which is 10’957 * 86’400s.
+// —end example]
+
+
+#include <chrono>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using local_t = std::chrono::local_t;
+    using year    = std::chrono::year;
+
+    using seconds = std::chrono::seconds;
+    using minutes = std::chrono::minutes;
+    using days    = std::chrono::days;
+    
+    using local_seconds = std::chrono::local_seconds;
+    using local_minutes = std::chrono::local_time<minutes>;
+    using local_days    = std::chrono::local_days;
+
+    constexpr std::chrono::month January = std::chrono::January;
+
+    ASSERT_SAME_TYPE(std::chrono::local_time<seconds>, local_seconds);
+    ASSERT_SAME_TYPE(std::chrono::local_time<days>,    local_days);
+
+//  Test the long form, too
+    ASSERT_SAME_TYPE(std::chrono::time_point<local_t, seconds>, local_seconds);
+    ASSERT_SAME_TYPE(std::chrono::time_point<local_t, minutes>, local_minutes);
+    ASSERT_SAME_TYPE(std::chrono::time_point<local_t, days>,    local_days);
+    
+//  Test some well known values
+    local_days d0 = local_days{year{1970}/January/1};
+    local_days d1 = local_days{year{2000}/January/1};
+    ASSERT_SAME_TYPE(decltype(d0.time_since_epoch()), days);
+    assert( d0.time_since_epoch().count() == 0);
+    assert( d1.time_since_epoch().count() == 10957);
+
+    local_seconds s0{d0};
+    local_seconds s1{d1};
+    ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
+    assert( s0.time_since_epoch().count() == 0);
+    assert( s1.time_since_epoch().count() == 946684800L);
+}
diff --git a/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
new file mode 100644
index 000000000..299e06818
--- /dev/null
+++ b/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+
+// template<class Duration>
+//   using sys_time  = time_point<system_clock, Duration>;
+// using sys_seconds = sys_time<seconds>;
+// using sys_days    = sys_time<days>;
+
+// [Example: 
+//   sys_seconds{sys_days{1970y/January/1}}.time_since_epoch() is 0s. 
+//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946’684’800s, which is 10’957 * 86’400s.
+// —end example]
+
+
+#include <chrono>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using system_clock = std::chrono::system_clock;
+    using year         = std::chrono::year;
+
+    using seconds = std::chrono::seconds;
+    using minutes = std::chrono::minutes;
+    using days    = std::chrono::days;
+    
+    using sys_seconds = std::chrono::sys_seconds;
+    using sys_minutes = std::chrono::sys_time<minutes>;
+    using sys_days    = std::chrono::sys_days;
+
+    constexpr std::chrono::month January = std::chrono::January;
+
+    ASSERT_SAME_TYPE(std::chrono::sys_time<seconds>, sys_seconds);
+    ASSERT_SAME_TYPE(std::chrono::sys_time<days>,    sys_days);
+
+//  Test the long form, too
+    ASSERT_SAME_TYPE(std::chrono::time_point<system_clock, seconds>, sys_seconds);
+    ASSERT_SAME_TYPE(std::chrono::time_point<system_clock, minutes>, sys_minutes);
+    ASSERT_SAME_TYPE(std::chrono::time_point<system_clock, days>,    sys_days);
+    
+//  Test some well known values
+    sys_days d0 = sys_days{year{1970}/January/1};
+    sys_days d1 = sys_days{year{2000}/January/1};
+    ASSERT_SAME_TYPE(decltype(d0.time_since_epoch()), days);
+    assert( d0.time_since_epoch().count() == 0);
+    assert( d1.time_since_epoch().count() == 10957);
+
+    sys_seconds s0{d0};
+    sys_seconds s1{d1};
+    ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
+    assert( s0.time_since_epoch().count() == 0);
+    assert( s1.time_since_epoch().count() == 946684800L);
+}
-- 
GitLab


From ef48e7bccee4f956744564e47b9c932e0605f7a8 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Fri, 11 Jan 2019 15:45:56 +0000
Subject: [PATCH 036/137] Don't use the form '2017y' in tests, since some gcc
 versions don't allow it

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350930 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../time.cal.ymd.members/op.local_days.pass.cpp             | 6 +++---
 .../time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp  | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
index 720a1c800..a70fe30fc 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
@@ -40,9 +40,9 @@ void RunTheExample()
 {
     using namespace std::chrono;
 
-    static_assert(year_month_day{local_days{2017y/January/0}}  == 2016y/December/31);
-    static_assert(year_month_day{local_days{2017y/January/31}} == 2017y/January/31);
-    static_assert(year_month_day{local_days{2017y/January/32}} == 2017y/February/1);  
+    static_assert(year_month_day{local_days{year{2017}/January/0}}  == year{2016}/December/31);
+    static_assert(year_month_day{local_days{year{2017}/January/31}} == year{2017}/January/31);
+    static_assert(year_month_day{local_days{year{2017}/January/32}} == year{2017}/February/1);  
 }
 
 int main()
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
index da9865d9c..4e263bccc 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
@@ -40,9 +40,9 @@ void RunTheExample()
 {
     using namespace std::chrono;
 
-    static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
-    static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
-    static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);  
+    static_assert(year_month_day{sys_days{year{2017}/January/0}}  == year{2016}/December/31);
+    static_assert(year_month_day{sys_days{year{2017}/January/31}} == year{2017}/January/31);
+    static_assert(year_month_day{sys_days{year{2017}/January/32}} == year{2017}/February/1);  
 }
 
 int main()
-- 
GitLab


From 7aafc4d66a52bf0c6f03db4b805b844b3c79dffa Mon Sep 17 00:00:00 2001
From: Adhemerval Zanella <adhemerval.zanella@linaro.org>
Date: Fri, 11 Jan 2019 17:31:17 +0000
Subject: [PATCH 037/137] [libcxx] Call __count_bool_true for bitset count

This patch aims to help clang with better information so it can inline
__bit_reference count function usage for both std::biset. Current clang
inliner can not infer that the passed typed will be used only to select
the optimized variant, it evaluates the type argument and type check as
a load plus compare (although later optimization phases correctly
optimized this out).

It is mainly to help llvm inliner to generate better code for std::bitset
count for aarch64. It helps on both runtime and code size, since if inline
decides that _VSTD::count should not be inlined the vectorization will
create both aligned and unaligned variants (which add both code size and
runtime costs)



git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350936 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/bitset | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/bitset b/include/bitset
index 6e28596d0..98947e027 100644
--- a/include/bitset
+++ b/include/bitset
@@ -991,7 +991,7 @@ inline
 size_t
 bitset<_Size>::count() const _NOEXCEPT
 {
-    return static_cast<size_t>(_VSTD::count(base::__make_iter(0), base::__make_iter(_Size), true));
+    return static_cast<size_t>(__count_bool_true(base::__make_iter(0), _Size));
 }
 
 template <size_t _Size>
-- 
GitLab


From 749373168df326e54446b407190fbd064bfee64f Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Fri, 11 Jan 2019 21:57:12 +0000
Subject: [PATCH 038/137] Change  from a  to a . Fixes PR#39871.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@350972 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/__tuple                                | 18 +++++++++---------
 include/array                                  |  4 ++--
 include/tuple                                  |  4 ++--
 include/utility                                |  4 ++--
 .../tuple_size_incomplete.fail.cpp             |  8 ++++----
 .../tuple_size_incomplete.pass.cpp             |  4 ++--
 .../tuple_size_structured_bindings.pass.cpp    |  4 ++--
 7 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/include/__tuple b/include/__tuple
index 69d6ee961..3b23d78af 100644
--- a/include/__tuple
+++ b/include/__tuple
@@ -22,36 +22,36 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size;
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size;
 
 #if !defined(_LIBCPP_CXX03_LANG)
 template <class _Tp, class...>
 using __enable_if_tuple_size_imp = _Tp;
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
+struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
     const _Tp,
     typename enable_if<!is_volatile<_Tp>::value>::type,
     integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
     : public integral_constant<size_t, tuple_size<_Tp>::value> {};
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
+struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
     volatile _Tp,
     typename enable_if<!is_const<_Tp>::value>::type,
     integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
     : public integral_constant<size_t, tuple_size<_Tp>::value> {};
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
+struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
     const volatile _Tp,
     integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
     : public integral_constant<size_t, tuple_size<_Tp>::value> {};
 
 #else
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
 #endif
 
 template <size_t _Ip, class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_element;
@@ -165,7 +165,7 @@ template <class ..._Tp> class _LIBCPP_TEMPLATE_VIS tuple;
 template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
 
 template <class ..._Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> >
+struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> >
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
@@ -291,7 +291,7 @@ public:
 
 
 template <class ..._Tp>
-class _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> >
+struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> >
     : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
diff --git a/include/array b/include/array
index 8f4e111ac..56f688765 100644
--- a/include/array
+++ b/include/array
@@ -91,7 +91,7 @@ template <class T, size_t N>
 template <class T, size_t N >
   void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); // C++17
 
-template <class T> class tuple_size;
+template <class T> struct tuple_size;
 template <size_t I, class T> class tuple_element;
 template <class T, size_t N> struct tuple_size<array<T, N>>;
 template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N>>;
@@ -430,7 +430,7 @@ swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
 }
 
 template <class _Tp, size_t _Size>
-class _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> >
+struct _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> >
     : public integral_constant<size_t, _Size> {};
 
 template <size_t _Ip, class _Tp, size_t _Size>
diff --git a/include/tuple b/include/tuple
index 2e54a5f66..4cc69030b 100644
--- a/include/tuple
+++ b/include/tuple
@@ -84,8 +84,8 @@ template <class T, class Tuple>
   constexpr T make_from_tuple(Tuple&& t); // C++17
 
 // 20.4.1.4, tuple helper classes:
-template <class T> class tuple_size; // undefined
-template <class... T> class tuple_size<tuple<T...>>;
+template <class T> struct tuple_size; // undefined
+template <class... T> struct tuple_size<tuple<T...>>;
 template <class T>
  inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
 template <size_t I, class T> class tuple_element; // undefined
diff --git a/include/utility b/include/utility
index fb7f44705..3fa0bc4c7 100644
--- a/include/utility
+++ b/include/utility
@@ -103,7 +103,7 @@ swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
 struct piecewise_construct_t { };
 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 
-template <class T> class tuple_size;
+template <class T> struct tuple_size;
 template <size_t I, class T> class tuple_element;
 
 template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
@@ -683,7 +683,7 @@ make_pair(_T1 __x, _T2 __y)
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _T1, class _T2>
-  class _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
+  struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
     : public integral_constant<size_t, 2> {};
 
 template <size_t _Ip, class _T1, class _T2>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
index 818001833..05ff8a4df 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
@@ -12,7 +12,7 @@
 // template <class... Types> class tuple;
 
 // template <class... Types>
-//   class tuple_size<tuple<Types...>>
+//   struct tuple_size<tuple<Types...>>
 //     : public integral_constant<size_t, sizeof...(Types)> { };
 
 // UNSUPPORTED: c++98, c++03
@@ -26,19 +26,19 @@ struct Dummy2 {};
 struct Dummy3 {};
 
 template <>
-class std::tuple_size<Dummy1> {
+struct std::tuple_size<Dummy1> {
 public:
   static size_t value;
 };
 
 template <>
-class std::tuple_size<Dummy2> {
+struct std::tuple_size<Dummy2> {
 public:
   static void value() {}
 };
 
 template <>
-class std::tuple_size<Dummy3> {};
+struct std::tuple_size<Dummy3> {};
 
 int main()
 {
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
index ccdd48e4c..c4f2e52ab 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
@@ -12,7 +12,7 @@
 // template <class... Types> class tuple;
 
 // template <class... Types>
-//   class tuple_size<tuple<Types...>>
+//   struct tuple_size<tuple<Types...>>
 //     : public integral_constant<size_t, sizeof...(Types)> { };
 
 // XFAIL: gcc-4.9
@@ -31,7 +31,7 @@ struct Dummy1 {};
 struct Dummy2 {};
 
 namespace std {
-template <> class tuple_size<Dummy1> : public integral_constant<size_t, 0> {};
+template <> struct tuple_size<Dummy1> : public integral_constant<size_t, 0> {};
 }
 
 template <class T>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
index 03fb78caa..a18b9fc89 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
@@ -12,7 +12,7 @@
 // template <class... Types> class tuple;
 
 // template <class... Types>
-//   class tuple_size<tuple<Types...>>
+//   struct tuple_size<tuple<Types...>>
 //     : public integral_constant<size_t, sizeof...(Types)> { };
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
@@ -129,7 +129,7 @@ void test_before_tuple_size_specialization() {
 }
 
 template <>
-class std::tuple_size<Test> {
+struct std::tuple_size<Test> {
 public:
   static const size_t value = 1;
 };
-- 
GitLab


From 7be0d09523e5fa311c2a8e17e928536ba97dfc40 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Sun, 13 Jan 2019 22:15:37 +0000
Subject: [PATCH 039/137] [libcxx] Mark do_open, do_get and do_close parameters
 unused when catopen is missing

When catopen is missing, do_open, do_get and do_close end up being
no-op, and as such their parameters will be unused which triggers a
warning/error when building with -Wunused-parameter.

Differential Revision: https://reviews.llvm.org/D56023

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351027 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/__config | 2 ++
 include/locale   | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/include/__config b/include/__config
index 728387642..e82d7fec5 100644
--- a/include/__config
+++ b/include/__config
@@ -1424,6 +1424,8 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #  endif // defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
 #endif // _LIBCPP_NO_AUTO_LINK
 
+#define _LIBCPP_UNUSED_VAR(x) ((void)(x))
+
 #endif // __cplusplus
 
 #endif // _LIBCPP_CONFIG
diff --git a/include/locale b/include/locale
index ac589d360..2043892fa 100644
--- a/include/locale
+++ b/include/locale
@@ -3568,6 +3568,7 @@ messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
         __cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1));
     return __cat;
 #else // !_LIBCPP_HAS_CATOPEN
+    _LIBCPP_UNUSED_VAR(__nm);
     return -1;
 #endif // _LIBCPP_HAS_CATOPEN
 }
@@ -3591,6 +3592,9 @@ messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
                                                         __n, __n + strlen(__n));
     return __w;
 #else // !_LIBCPP_HAS_CATOPEN
+    _LIBCPP_UNUSED_VAR(__c);
+    _LIBCPP_UNUSED_VAR(__set);
+    _LIBCPP_UNUSED_VAR(__msgid);
     return __dflt;
 #endif // _LIBCPP_HAS_CATOPEN
 }
@@ -3604,6 +3608,8 @@ messages<_CharT>::do_close(catalog __c) const
         __c <<= 1;
     nl_catd __cat = (nl_catd)__c;
     catclose(__cat);
+#else // !_LIBCPP_HAS_CATOPEN
+    _LIBCPP_UNUSED_VAR(__c);
 #endif // _LIBCPP_HAS_CATOPEN
 }
 
-- 
GitLab


From 65c8c4faa6a1e6a3cff7d67cbcc4d8e7aaf21827 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Tue, 15 Jan 2019 00:05:05 +0000
Subject: [PATCH 040/137] Generalize the comparison test structure to support
 cross-type comparisons. NFC to the library

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351140 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/support/test_comparisons.h | 72 ++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/test/support/test_comparisons.h b/test/support/test_comparisons.h
index f67a84fa2..cf094eb65 100644
--- a/test/support/test_comparisons.h
+++ b/test/support/test_comparisons.h
@@ -23,8 +23,8 @@
 #include "test_macros.h"
 
 //  Test all six comparison operations for sanity
-template <class T>
-TEST_CONSTEXPR_CXX14 bool testComparisons6(const T& t1, const T& t2, bool isEqual, bool isLess)
+template <class T, class U = T>
+TEST_CONSTEXPR_CXX14 bool testComparisons6(const T& t1, const U& t2, bool isEqual, bool isLess)
 {
     if (isEqual)
         {
@@ -85,43 +85,43 @@ TEST_CONSTEXPR_CXX14 bool testComparisons6Values(Param val1, Param val2)
     return testComparisons6(T(val1), T(val2), isEqual, isLess);
 }
 
-template <class T>
+template <class T, class U = T>
 void AssertComparisons6AreNoexcept()
 {
-    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const T&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const T&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const T&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const T&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() >  std::declval<const T&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const U&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const U&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() >  std::declval<const U&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const U&>());
 }
 
-template <class T>
+template <class T, class U = T>
 void AssertComparisons6ReturnBool()
 {
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const T&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const T&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <  std::declval<const T&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const T&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >  std::declval<const T&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <  std::declval<const U&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const U&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >  std::declval<const U&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const U&>()), bool);
 }
 
 
-template <class T>
+template <class T, class U = T>
 void AssertComparisons6ConvertibleToBool()
 {
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const T&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const T&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() <  std::declval<const T&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const T&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() >  std::declval<const T&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() <  std::declval<const U&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const U&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() >  std::declval<const U&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const U&>()), bool>::value), "");
 }
 
-//  Test all six comparison operations for sanity
-template <class T>
-TEST_CONSTEXPR_CXX14 bool testComparisons2(const T& t1, const T& t2, bool isEqual)
+//  Test all two comparison operations for sanity
+template <class T, class U = T>
+TEST_CONSTEXPR_CXX14 bool testComparisons2(const T& t1, const U& t2, bool isEqual)
 {
     if (isEqual)
         {
@@ -130,7 +130,7 @@ TEST_CONSTEXPR_CXX14 bool testComparisons2(const T& t1, const T& t2, bool isEqua
         if ( (t1 != t2)) return false;
         if ( (t2 != t1)) return false;
         }
-    else /* greater */
+    else /* not equal */
         {
         if ( (t1 == t2)) return false;
         if ( (t2 == t1)) return false;
@@ -150,26 +150,26 @@ TEST_CONSTEXPR_CXX14 bool testComparisons2Values(Param val1, Param val2)
     return testComparisons2(T(val1), T(val2), isEqual);
 }
 
-template <class T>
+template <class T, class U = T>
 void AssertComparisons2AreNoexcept()
 {
-    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const T&>());
-    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const T&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
+    ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
 }
 
-template <class T>
+template <class T, class U = T>
 void AssertComparisons2ReturnBool()
 {
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const T&>()), bool);
-    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const T&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
+    ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
 }
 
 
-template <class T>
+template <class T, class U = T>
 void AssertComparisons2ConvertibleToBool()
 {
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const T&>()), bool>::value), "");
-    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const T&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
+    static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
 }
 
 #endif // TEST_COMPARISONS_H
-- 
GitLab


From 9e69b7db4deac4dbd7c6ae0a4c4ec631fc76caeb Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Tue, 15 Jan 2019 01:53:12 +0000
Subject: [PATCH 041/137] [test] Fix logic error in <compare> tests; enable for
 MSVC Dev16

Submitted upstream as https://reviews.llvm.org/D53763.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351148 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../language.support/cmp/cmp.partialord/partialord.pass.cpp    | 2 +-
 test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp | 2 +-
 test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp     | 2 +-
 test/support/test_macros.h                                     | 3 ++-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp b/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
index a80477151..4ea823499 100644
--- a/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
@@ -130,7 +130,7 @@ constexpr bool test_constexpr() {
   };
   for (auto TC : SpaceshipTestCases)
   {
-    std::partial_ordering Res = (0 <=> TC.Value);
+    std::partial_ordering Res = (TC.Value <=> 0);
     switch (TC.Expect) {
     case ER_Equiv:
       assert(Res == 0);
diff --git a/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp b/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
index 0bdd68679..94668ab7c 100644
--- a/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
@@ -185,7 +185,7 @@ constexpr bool test_constexpr() {
   };
   for (auto TC : SpaceshipTestCases)
   {
-    std::strong_ordering Res = (0 <=> TC.Value);
+    std::strong_ordering Res = (TC.Value <=> 0);
     switch (TC.Expect) {
     case ER_Equiv:
       assert(Res == 0);
diff --git a/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp b/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
index 0a5268032..067f378e0 100644
--- a/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
@@ -142,7 +142,7 @@ constexpr bool test_constexpr() {
   };
   for (auto TC : SpaceshipTestCases)
   {
-    std::weak_ordering Res = (0 <=> TC.Value);
+    std::weak_ordering Res = (TC.Value <=> 0);
     switch (TC.Expect) {
     case ER_Equiv:
       assert(Res == 0);
diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index 88cc4d5ca..997555296 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -210,8 +210,9 @@
 
 // FIXME: Fix this feature check when either (A) a compiler provides a complete
 // implementation, or (b) a feature check macro is specified
+#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER < 1920 || _MSVC_LANG <= 201703L
 #define TEST_HAS_NO_SPACESHIP_OPERATOR
-
+#endif
 
 #if TEST_STD_VER < 11
 #define ASSERT_NOEXCEPT(...)
-- 
GitLab


From e315f32e354e29774665dba5935472715ede20e0 Mon Sep 17 00:00:00 2001
From: Hans Wennborg <hans@hanshq.net>
Date: Tue, 15 Jan 2019 15:10:32 +0000
Subject: [PATCH 042/137] Update year in license files

In last year's update (D48219) it was suggested that the release manager
might want to do this, so here we go.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351194 91177308-0d34-0410-b5e6-96231b3b80d8
---
 LICENSE.TXT | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE.TXT b/LICENSE.TXT
index c278f2c92..190d9394d 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -14,7 +14,7 @@ Full text of the relevant licenses is included below.
 University of Illinois/NCSA
 Open Source License
 
-Copyright (c) 2009-2017 by the contributors listed in CREDITS.TXT
+Copyright (c) 2009-2019 by the contributors listed in CREDITS.TXT
 
 All rights reserved.
 
-- 
GitLab


From b7b2997a4a2170ca13111c8ff90adbc58bfd9197 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Tue, 15 Jan 2019 18:55:55 +0000
Subject: [PATCH 043/137] [libc++] Support different libc++ namespaces in the
 iterator test

libc++ allows changing the namespace, don't assume __1 in the test
to avoid the test failure if different namespace is being used.

Differential Revision: https://reviews.llvm.org/D56698

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351220 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../iterator.traits/empty.fail.cpp            | 60 +++++++++----------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp b/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
index 021523481..0fab1aa15 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
@@ -68,55 +68,55 @@ int main()
 {
     {
     typedef std::iterator_traits<NotAnIteratorEmpty> T;
-    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::__1::iterator_traits<{{.+}}>}}
+    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoDifference> T;
-    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::__1::iterator_traits<{{.+}}>}}
+    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoValue> T;
-    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::__1::iterator_traits<{{.+}}>}}
+    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoPointer> T;
-    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::__1::iterator_traits<{{.+}}>}}
+    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoReference> T;
-    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::__1::iterator_traits<{{.+}}>}}
+    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
 
     {
     typedef std::iterator_traits<NotAnIteratorNoCategory> T;
-    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::__1::iterator_traits<{{.+}}>}}
-    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::__1::iterator_traits<{{.+}}>}}
+    typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::value_type        VT; // expected-error-re {{no type named 'value_type' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::pointer           PT; // expected-error-re {{no type named 'pointer' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
+    typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
 }
-- 
GitLab


From ae62476eac4f4d46a64317be2ac7078aa79dc786 Mon Sep 17 00:00:00 2001
From: Dan Albert <danalbert@google.com>
Date: Tue, 15 Jan 2019 19:14:15 +0000
Subject: [PATCH 044/137] Add large file support to create_file for 32-bit.

Summary:
The tests need to create files larger than 2GB, but size_t is 32-bit
on a 32-bit system. Make use of explicit off64_t APIs so we can still
use a default off_t for the tests while enabling 64-bit file offsets
for create_file.

Reviewers: mclow.lists, EricWF

Reviewed By: EricWF

Subscribers: christof, ldionne, libcxx-commits

Differential Revision: https://reviews.llvm.org/D56619

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351225 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/support/filesystem_test_helper.hpp | 46 ++++++++++++++++++++++---
 1 file changed, 41 insertions(+), 5 deletions(-)

diff --git a/test/support/filesystem_test_helper.hpp b/test/support/filesystem_test_helper.hpp
index f02792870..467abd5fc 100644
--- a/test/support/filesystem_test_helper.hpp
+++ b/test/support/filesystem_test_helper.hpp
@@ -2,6 +2,9 @@
 #define FILESYSTEM_TEST_HELPER_HPP
 
 #include "filesystem_include.hpp"
+
+#include <unistd.h> // for ftruncate
+
 #include <cassert>
 #include <cstdio> // for printf
 #include <string>
@@ -147,13 +150,46 @@ struct scoped_test_env
         return raw;
     }
 
-    std::string create_file(std::string filename, std::size_t size = 0) {
+    // Purposefully using a size potentially larger than off_t here so we can
+    // test the behavior of libc++fs when it is built with _FILE_OFFSET_BITS=64
+    // but the caller is not (std::filesystem also uses uintmax_t rather than
+    // off_t). On a 32-bit system this allows us to create a file larger than
+    // 2GB.
+    std::string create_file(std::string filename, uintmax_t size = 0) {
+#if defined(__LP64__)
+        auto large_file_fopen = fopen;
+        auto large_file_ftruncate = ftruncate;
+        using large_file_offset_t = off_t;
+#else
+        auto large_file_fopen = fopen64;
+        auto large_file_ftruncate = ftruncate64;
+        using large_file_offset_t = off64_t;
+#endif
+
         filename = sanitize_path(std::move(filename));
-        std::string out_str(size, 'a');
-        {
-            std::ofstream out(filename.c_str());
-            out << out_str;
+
+        if (size > std::numeric_limits<large_file_offset_t>::max()) {
+            fprintf(stderr, "create_file(%s, %ju) too large\n",
+                    filename.c_str(), size);
+            abort();
         }
+
+        FILE* file = large_file_fopen(filename.c_str(), "we");
+        if (file == nullptr) {
+            fprintf(stderr, "fopen %s failed: %s\n", filename.c_str(),
+                    strerror(errno));
+            abort();
+        }
+
+        if (large_file_ftruncate(
+                fileno(file), static_cast<large_file_offset_t>(size)) == -1) {
+            fprintf(stderr, "ftruncate %s %ju failed: %s\n", filename.c_str(),
+                    size, strerror(errno));
+            fclose(file);
+            abort();
+        }
+
+        fclose(file);
         return filename;
     }
 
-- 
GitLab


From 3ea6c6b30c613d1269e27b7bc4725077f5dac520 Mon Sep 17 00:00:00 2001
From: Dan Albert <danalbert@google.com>
Date: Tue, 15 Jan 2019 19:16:25 +0000
Subject: [PATCH 045/137] Fix size_t/off_t mixup in std::filesystem.

Summary: ftruncate takes an off_t, not a size_t.

Reviewers: EricWF, mclow.lists

Reviewed By: EricWF

Subscribers: christof, ldionne, libcxx-commits

Differential Revision: https://reviews.llvm.org/D56578

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351226 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/filesystem/operations.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/filesystem/operations.cpp b/src/filesystem/operations.cpp
index e3bbc7b64..b41061888 100644
--- a/src/filesystem/operations.cpp
+++ b/src/filesystem/operations.cpp
@@ -439,7 +439,8 @@ file_status posix_lstat(path const& p, error_code* ec) {
   return posix_lstat(p, path_stat, ec);
 }
 
-bool posix_ftruncate(const FileDescriptor& fd, size_t to_size, error_code& ec) {
+// http://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html
+bool posix_ftruncate(const FileDescriptor& fd, off_t to_size, error_code& ec) {
   if (::ftruncate(fd.fd, to_size) == -1) {
     ec = capture_errno();
     return true;
-- 
GitLab


From a8b9f59e8caf378d56e8bfcecdb22184cdabf42d Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 16 Jan 2019 01:37:43 +0000
Subject: [PATCH 046/137] Implement feature test macros using a script.

Summary:
This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a.

The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++.
When a new feature test macro is added or needed, the table should be updated and the script re-run.



Reviewers: mclow.lists, jfb, serge-sans-paille

Reviewed By: mclow.lists

Subscribers: arphaman, jfb, ldionne, libcxx-commits

Differential Revision: https://reviews.llvm.org/D56750

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351286 91177308-0d34-0410-b5e6-96231b3b80d8
---
 docs/DesignDocs/FeatureTestMacros.rst         |   44 +
 docs/FeatureTestMacroTable.rst                |  200 ++
 docs/index.rst                                |    7 +
 include/version                               |  278 +-
 .../algorithm.version.pass.cpp                |  195 +-
 .../any.version.pass.cpp                      |   55 +-
 .../array.version.pass.cpp                    |  105 +-
 .../atomic.version.pass.cpp                   |  127 +-
 .../bit.version.pass.cpp                      |   58 +-
 .../chrono.version.pass.cpp                   |   82 +-
 .../cmath.version.pass.cpp                    |   91 +-
 .../compare.version.pass.cpp                  |   57 +-
 .../complex.version.pass.cpp                  |   58 +-
 .../cstddef.version.pass.cpp                  |   55 +-
 .../deque.version.pass.cpp                    |  112 +-
 .../exception.version.pass.cpp                |   55 +-
 .../filesystem.version.pass.cpp               |   98 +-
 .../forward_list.version.pass.cpp             |  163 +-
 .../functional.version.pass.cpp               |  252 +-
 .../generate_feature_test_macro_components.py |  959 +++++++
 .../iomanip.version.pass.cpp                  |   58 +-
 .../istream.version.pass.cpp                  |   64 +-
 .../iterator.version.pass.cpp                 |  185 +-
 .../limits.version.pass.cpp                   |   64 +-
 .../list.version.pass.cpp                     |  163 +-
 .../locale.version.pass.cpp                   |   64 +-
 .../map.version.pass.cpp                      |  187 +-
 .../memory.version.pass.cpp                   |  255 +-
 .../mutex.version.pass.cpp                    |   55 +-
 .../new.version.pass.cpp                      |  105 +-
 .../numeric.version.pass.cpp                  |   91 +-
 .../optional.version.pass.cpp                 |   55 +-
 .../ostream.version.pass.cpp                  |   64 +-
 .../regex.version.pass.cpp                    |   55 +-
 .../scoped_allocator.version.pass.cpp         |   55 +-
 .../set.version.pass.cpp                      |  163 +-
 .../shared_mutex.version.pass.cpp             |   84 +-
 .../string.version.pass.cpp                   |  192 +-
 .../string_view.version.pass.cpp              |  116 +-
 .../tuple.version.pass.cpp                    |  159 +-
 .../type_traits.version.pass.cpp              |  413 ++-
 .../unordered_map.version.pass.cpp            |  179 +-
 .../unordered_set.version.pass.cpp            |  162 +-
 .../utility.version.pass.cpp                  |  197 +-
 .../variant.version.pass.cpp                  |   55 +-
 .../vector.version.pass.cpp                   |  136 +-
 .../version.version.pass.cpp                  | 2237 ++++++++++++++++-
 test/support/test_macros.h                    |    1 +
 48 files changed, 7519 insertions(+), 1146 deletions(-)
 create mode 100644 docs/DesignDocs/FeatureTestMacros.rst
 create mode 100644 docs/FeatureTestMacroTable.rst
 create mode 100755 test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py

diff --git a/docs/DesignDocs/FeatureTestMacros.rst b/docs/DesignDocs/FeatureTestMacros.rst
new file mode 100644
index 000000000..d55af96c6
--- /dev/null
+++ b/docs/DesignDocs/FeatureTestMacros.rst
@@ -0,0 +1,44 @@
+===================
+Feature Test Macros
+===================
+
+.. contents::
+   :local:
+
+Overview
+========
+
+Libc++ implements the C++ feature test macros as specified in the C++2a standard,
+and before that in non-normative guiding documents (`See cppreference <https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros>`)
+
+Design
+======
+
+Feature test macros are tricky to track, implement, test, and document correctly.
+They must be available from a list of headers, they may have different values in
+different dialects, and they may or may not be implemented by libc++. In order to
+track all of these conditions correctly and easily, we want a Single Source of
+Truth (SSoT) that defines each feature test macro, its values, the headers it
+lives in, and whether or not is is implemented by libc++. From this SSoA we
+have enough information to automatically generate the `<version>` header,
+the tests, and the documentation.
+
+Therefore we maintain a SSoA in
+`libcxx/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py`
+which doubles as a script to generate the following components:
+
+* The `<version>` header.
+* The version tests under `support.limits.general`.
+* Documentation of libc++'s implementation of each macro.
+
+Usage
+=====
+
+The `generate_feature_test_macro_components.py` script is used to track and
+update feature test macros in libc++.
+
+Whenever a feature test macro is added or changed, the table should be updated
+and the script should be re-ran. The script will clobber the existing test files
+and the documentation and it will generate a new `<version>` header as a
+temporary file. The generated `<version>` header should be merged with the
+existing one.
\ No newline at end of file
diff --git a/docs/FeatureTestMacroTable.rst b/docs/FeatureTestMacroTable.rst
new file mode 100644
index 000000000..d900497eb
--- /dev/null
+++ b/docs/FeatureTestMacroTable.rst
@@ -0,0 +1,200 @@
+.. _FeatureTestMacroTable:
+
+==========================
+Feature Test Macro Support
+==========================
+
+.. contents::
+   :local:
+
+Overview
+========
+
+This file documents the feature test macros currently supported by libc++.
+
+.. _feature-status:
+
+Status
+======
+
+.. table:: Current Status
+     :name: feature-status-table
+     :widths: auto
+     
+    ================================================= =================
+    Macro Name                                        Value            
+    ================================================= =================
+    **C++ 14**                                                         
+    -------------------------------------------------------------------
+    ``__cpp_lib_chrono_udls``                         ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_complex_udls``                        ``201309L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_exchange_function``                   ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_generic_associative_lookup``          ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_integer_sequence``                    ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_integral_constant_callable``          ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_is_final``                            ``201402L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_is_null_pointer``                     ``201309L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_make_reverse_iterator``               ``201402L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_make_unique``                         ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_null_iterators``                      ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_quoted_string_io``                    ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_result_of_sfinae``                    ``201210L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_robust_nonmodifying_seq_ops``         ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_shared_timed_mutex``                  ``201402L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_string_udls``                         ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_transformation_trait_aliases``        ``201304L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_transparent_operators``               ``201210L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_tuple_element_t``                     ``201402L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_tuples_by_type``                      ``201304L``      
+    ------------------------------------------------- -----------------
+    **C++ 17**                                                         
+    -------------------------------------------------------------------
+    ``__cpp_lib_addressof_constexpr``                 ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_allocator_traits_is_always_equal``    ``201411L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_any``                                 ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_apply``                               ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_array_constexpr``                     ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_as_const``                            ``201510L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_atomic_is_always_lock_free``          ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_bool_constant``                       ``201505L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_boyer_moore_searcher``                *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_byte``                                ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_chrono``                              ``201611L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_clamp``                               ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_enable_shared_from_this``             ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_execution``                           *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_filesystem``                          ``201703L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_gcd_lcm``                             ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_hardware_interference_size``          ``201703L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_has_unique_object_representations``   ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_hypot``                               ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_incomplete_container_elements``       ``201505L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_invoke``                              ``201411L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_is_aggregate``                        ``201703L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_is_invocable``                        ``201703L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_is_swappable``                        ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_launder``                             ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_logical_traits``                      ``201510L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_make_from_tuple``                     ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_map_try_emplace``                     ``201411L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_math_special_functions``              *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_memory_resource``                     *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_node_extract``                        ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_nonmember_container_access``          ``201411L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_not_fn``                              ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_optional``                            ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_parallel_algorithm``                  *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_raw_memory_algorithms``               ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_sample``                              ``201603L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_scoped_lock``                         ``201703L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_shared_mutex``                        ``201505L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_shared_ptr_arrays``                   *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_shared_ptr_weak_type``                ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_string_view``                         ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_to_chars``                            *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_transparent_operators``               ``201510L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_type_trait_variable_templates``       ``201510L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_uncaught_exceptions``                 ``201411L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_unordered_map_try_emplace``           ``201411L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_variant``                             ``201606L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_void_t``                              ``201411L``      
+    ------------------------------------------------- -----------------
+    **C++ 2a**                                                         
+    -------------------------------------------------------------------
+    ``__cpp_lib_atomic_ref``                          *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_bind_front``                          *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_bit_cast``                            *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_char8_t``                             ``201811L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_concepts``                            *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_constexpr_misc``                      *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_constexpr_swap_algorithms``           *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_destroying_delete``                   *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_erase_if``                            ``201811L``      
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_generic_unordered_lookup``            *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_is_constant_evaluated``               *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_list_remove_return_type``             *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_ranges``                              *unimplemented*  
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_three_way_comparison``                *unimplemented*  
+    ================================================= =================
+
+
diff --git a/docs/index.rst b/docs/index.rst
index bb56f2da0..fddf74b66 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -40,6 +40,11 @@ Getting Started with libc++
    TestingLibcxx
 
 
+.. toctree::
+    :hidden:
+
+    FeatureTestMacroTable
+
 Current Status
 --------------
 
@@ -107,6 +112,7 @@ C++ Dialect Support
 * `C++14 - Complete <http://libcxx.llvm.org/cxx1y_status.html>`__
 * `C++17 - In Progress <http://libcxx.llvm.org/cxx1z_status.html>`__
 * `Post C++14 Technical Specifications - In Progress <http://libcxx.llvm.org/ts1z_status.html>`__
+* :ref:`C++ Feature Test Macro Status <feature-status>`
 
 Notes and Known Issues
 ----------------------
@@ -136,6 +142,7 @@ Design Documents
    DesignDocs/VisibilityMacros
    DesignDocs/ThreadingSupportAPI
    DesignDocs/FileTimeType
+   DesignDocs/FeatureTestMacros
 
 * `<atomic> design <http://libcxx.llvm.org/atomic_design.html>`_
 * `<type_traits> design <http://libcxx.llvm.org/type_traits_design.html>`_
diff --git a/include/version b/include/version
index d6ccb138f..d37aba139 100644
--- a/include/version
+++ b/include/version
@@ -12,92 +12,105 @@
 #define _LIBCPP_VERSIONH
 
 /*
-    version synopsis
+  version synopsis
 
-    Table 35 — Standard library feature-test macros
-Macro name                                  Value   Headers
-__cpp_lib_addressof_constexpr               201603L <memory>
-__cpp_lib_allocator_traits_is_always_equal  201411L <memory> <scoped_allocator> <string> 
-                                                    <deque> <forward_list> <list> <vector>
-                                                    <map> <set> <unordered_map> <unordered_set>
-__cpp_lib_any                               201606L <any>
-__cpp_lib_apply                             201603L <tuple>
-__cpp_lib_array_constexpr                   201603L <iterator> <array>
-__cpp_lib_as_const                          201510L <utility>
-__cpp_lib_atomic_is_always_lock_free        201603L <atomic>
-__cpp_lib_atomic_ref                        201806L <atomic>
-__cpp_lib_bit_cast                          201806L <bit>
-__cpp_lib_bool_constant                     201505L <type_traits>
-__cpp_lib_boyer_moore_searcher              201603L <functional>
-__cpp_lib_byte                              201603L <cstddef>
-__cpp_lib_char8_t                           201811L <atomic> <filesystem> <istream> <limits>
-                                                    <locale> <ostream> <string> <string_view>
-__cpp_lib_chrono                            201611L <chrono>
-__cpp_lib_chrono_udls                       201304L <chrono>
-__cpp_lib_clamp                             201603L <algorithm>
-__cpp_lib_complex_udls                      201309L <complex>
-__cpp_lib_concepts                          201806L <concepts>
-__cpp_lib_constexpr_swap_algorithms         201806L <algorithm>
-__cpp_lib_enable_shared_from_this           201603L <memory>
-__cpp_lib_erase_if                          201811L <string> <deque> <forward_list> <list> 
-                                                    <vector> <map> <set> <unordered_map> 
-                                                    <unordered_set>
-__cpp_lib_exchange_function                 201304L <utility>
-__cpp_lib_execution                         201603L <execution>
-__cpp_lib_filesystem                        201703L <filesystem>
-__cpp_lib_gcd_lcm                           201606L <numeric>
-__cpp_lib_generic_associative_lookup        201304L <map> <set>
-__cpp_lib_hardware_interference_size        201703L <new>
-__cpp_lib_has_unique_object_representations 201606L <type_traits>
-__cpp_lib_hypot                             201603L <cmath>
-__cpp_lib_incomplete_container_elements     201505L <forward_list> <list> <vector>
-__cpp_lib_integer_sequence                  201304L <utility>
-__cpp_lib_integral_constant_callable        201304L <type_traits>
-__cpp_lib_invoke                            201411L <functional>
-__cpp_lib_is_aggregate                      201703L <type_traits>
-__cpp_lib_is_final                          201402L <type_traits>
-__cpp_lib_is_invocable                      201703L <type_traits>
-__cpp_lib_is_null_pointer                   201309L <type_traits>
-__cpp_lib_is_swappable                      201603L <type_traits>
-__cpp_lib_launder                           201606L <new>
-__cpp_lib_list_remove_return_type           201806L <forward_list> <list>
-__cpp_lib_logical_traits                    201510L <type_traits>
-__cpp_lib_make_from_tuple                   201606L <tuple>
-__cpp_lib_make_reverse_iterator             201402L <iterator>
-__cpp_lib_make_unique                       201304L <memory>
-__cpp_lib_map_try_emplace                   201411L <map>
-__cpp_lib_math_special_functions            201603L <cmath>
-__cpp_lib_memory_resource                   201603L <memory_resource>
-__cpp_lib_node_extract                      201606L <map> <set> <unordered_map> <unordered_set>
-__cpp_lib_nonmember_container_access        201411L <iterator> <array> <deque> <forward_list>
-                                                    <list> <map> <regex> <set> <string>
-                                                    <unordered_map> <unordered_set> <vector>
-__cpp_lib_not_fn                            201603L <functional>
-__cpp_lib_null_iterators                    201304L <iterator>
-__cpp_lib_optional                          201606L <optional>
-__cpp_lib_parallel_algorithm                201603L <algorithm> <numeric>
-__cpp_lib_quoted_string_io                  201304L <iomanip>
-__cpp_lib_raw_memory_algorithms             201606L <memory>
-__cpp_lib_result_of_sfinae                  201210L <functional> <type_traits>
-__cpp_lib_robust_nonmodifying_seq_ops       201304L <algorithm>
-__cpp_lib_sample                            201603L <algorithm>
-__cpp_lib_scoped_lock                       201703L <mutex>
-__cpp_lib_shared_mutex                      201505L <shared_mutex>
-__cpp_lib_shared_ptr_arrays                 201611L <memory>
-__cpp_lib_shared_ptr_weak_type              201606L <memory>
-__cpp_lib_shared_timed_mutex                201402L <shared_mutex>
-__cpp_lib_string_udls                       201304L <string>
-__cpp_lib_string_view                       201606L <string> <string_view>
-__cpp_lib_to_chars                          201611L <charconv>
-__cpp_lib_transformation_trait_aliases      201304L <type_traits>
-__cpp_lib_transparent_operators             201510L <memory> <functional>
-__cpp_lib_tuple_element_t                   201402L <tuple>
-__cpp_lib_tuples_by_type                    201304L <utility> <tuple>
-__cpp_lib_type_trait_variable_templates     201510L <type_traits>
-__cpp_lib_uncaught_exceptions               201411L <exception>
-__cpp_lib_unordered_map_try_emplace         201411L <unordered_map>
-__cpp_lib_variant                           201606L <variant>
-__cpp_lib_void_t                            201411L <type_traits>
+Macro name                                              Value   Headers
+__cpp_lib_addressof_constexpr                           201603L <memory>
+__cpp_lib_allocator_traits_is_always_equal              201411L <memory> <scoped_allocator> <string>
+                                                                <deque> <forward_list> <list>
+                                                                <vector> <map> <set>
+                                                                <unordered_map> <unordered_set>
+__cpp_lib_any                                           201606L <any>
+__cpp_lib_apply                                         201603L <tuple>
+__cpp_lib_array_constexpr                               201603L <iterator> <array>
+__cpp_lib_as_const                                      201510L <utility>
+__cpp_lib_atomic_is_always_lock_free                    201603L <atomic>
+__cpp_lib_atomic_ref                                    201806L <atomic>
+__cpp_lib_bind_front                                    201811L <functional>
+__cpp_lib_bit_cast                                      201806L <bit>
+__cpp_lib_bool_constant                                 201505L <type_traits>
+__cpp_lib_boyer_moore_searcher                          201603L <functional>
+__cpp_lib_byte                                          201603L <cstddef>
+__cpp_lib_char8_t                                       201811L <atomic> <filesystem> <istream>
+                                                                <limits> <locale> <ostream>
+                                                                <string> <string_view>
+__cpp_lib_chrono                                        201611L <chrono>
+__cpp_lib_chrono_udls                                   201304L <chrono>
+__cpp_lib_clamp                                         201603L <algorithm>
+__cpp_lib_complex_udls                                  201309L <complex>
+__cpp_lib_concepts                                      201806L <concepts>
+__cpp_lib_constexpr_misc                                201811L <array> <functional> <iterator>
+                                                                <string_view> <tuple> <utility>
+__cpp_lib_constexpr_swap_algorithms                     201806L <algorithm>
+__cpp_lib_destroying_delete                             201806L <new>
+__cpp_lib_enable_shared_from_this                       201603L <memory>
+__cpp_lib_erase_if                                      201811L <string> <deque> <forward_list>
+                                                                <list> <vector> <map>
+                                                                <set> <unordered_map> <unordered_set>
+__cpp_lib_exchange_function                             201304L <utility>
+__cpp_lib_execution                                     201603L <execution>
+__cpp_lib_filesystem                                    201703L <filesystem>
+__cpp_lib_gcd_lcm                                       201606L <numeric>
+__cpp_lib_generic_associative_lookup                    201304L <map> <set>
+__cpp_lib_generic_unordered_lookup                      201811L <unordered_map> <unordered_set>
+__cpp_lib_hardware_interference_size                    201703L <new>
+__cpp_lib_has_unique_object_representations             201606L <type_traits>
+__cpp_lib_hypot                                         201603L <cmath>
+__cpp_lib_incomplete_container_elements                 201505L <forward_list> <list> <vector>
+__cpp_lib_integer_sequence                              201304L <utility>
+__cpp_lib_integral_constant_callable                    201304L <type_traits>
+__cpp_lib_invoke                                        201411L <functional>
+__cpp_lib_is_aggregate                                  201703L <type_traits>
+__cpp_lib_is_constant_evaluated                         201811L <type_traits>
+__cpp_lib_is_final                                      201402L <type_traits>
+__cpp_lib_is_invocable                                  201703L <type_traits>
+__cpp_lib_is_null_pointer                               201309L <type_traits>
+__cpp_lib_is_swappable                                  201603L <type_traits>
+__cpp_lib_launder                                       201606L <new>
+__cpp_lib_list_remove_return_type                       201806L <forward_list> <list>
+__cpp_lib_logical_traits                                201510L <type_traits>
+__cpp_lib_make_from_tuple                               201606L <tuple>
+__cpp_lib_make_reverse_iterator                         201402L <iterator>
+__cpp_lib_make_unique                                   201304L <memory>
+__cpp_lib_map_try_emplace                               201411L <map>
+__cpp_lib_math_special_functions                        201603L <cmath>
+__cpp_lib_memory_resource                               201603L <memory_resource>
+__cpp_lib_node_extract                                  201606L <map> <set> <unordered_map>
+                                                                <unordered_set>
+__cpp_lib_nonmember_container_access                    201411L <iterator> <array> <deque>
+                                                                <forward_list> <list> <map>
+                                                                <regex> <set> <string>
+                                                                <unordered_map> <unordered_set> <vector>
+__cpp_lib_not_fn                                        201603L <functional>
+__cpp_lib_null_iterators                                201304L <iterator>
+__cpp_lib_optional                                      201606L <optional>
+__cpp_lib_parallel_algorithm                            201603L <algorithm> <numeric>
+__cpp_lib_quoted_string_io                              201304L <iomanip>
+__cpp_lib_ranges                                        201811L <algorithm> <functional> <iterator>
+                                                                <memory> <ranges>
+__cpp_lib_raw_memory_algorithms                         201606L <memory>
+__cpp_lib_result_of_sfinae                              201210L <functional> <type_traits>
+__cpp_lib_robust_nonmodifying_seq_ops                   201304L <algorithm>
+__cpp_lib_sample                                        201603L <algorithm>
+__cpp_lib_scoped_lock                                   201703L <mutex>
+__cpp_lib_shared_mutex                                  201505L <shared_mutex>
+__cpp_lib_shared_ptr_arrays                             201611L <memory>
+__cpp_lib_shared_ptr_weak_type                          201606L <memory>
+__cpp_lib_shared_timed_mutex                            201402L <shared_mutex>
+__cpp_lib_string_udls                                   201304L <string>
+__cpp_lib_string_view                                   201606L <string> <string_view>
+__cpp_lib_three_way_comparison                          201711L <compare>
+__cpp_lib_to_chars                                      201611L <utility>
+__cpp_lib_transformation_trait_aliases                  201304L <type_traits>
+__cpp_lib_transparent_operators                         201510L <functional>
+                                                        201210L // C++14
+__cpp_lib_tuple_element_t                               201402L <tuple>
+__cpp_lib_tuples_by_type                                201304L <utility> <tuple>
+__cpp_lib_type_trait_variable_templates                 201510L <type_traits>
+__cpp_lib_uncaught_exceptions                           201411L <exception>
+__cpp_lib_unordered_map_try_emplace                     201411L <unordered_map>
+__cpp_lib_variant                                       201606L <variant>
+__cpp_lib_void_t                                        201411L <type_traits>
 
 */
 
@@ -108,21 +121,104 @@ __cpp_lib_void_t                            201411L <type_traits>
 #endif
 
 #if _LIBCPP_STD_VER > 11
+# define __cpp_lib_chrono_udls                          201304L
+# define __cpp_lib_complex_udls                         201309L
+# define __cpp_lib_exchange_function                    201304L
+# define __cpp_lib_generic_associative_lookup           201304L
+# define __cpp_lib_integer_sequence                     201304L
+# define __cpp_lib_integral_constant_callable           201304L
+# define __cpp_lib_is_final                             201402L
+# define __cpp_lib_is_null_pointer                      201309L
+# define __cpp_lib_make_reverse_iterator                201402L
+# define __cpp_lib_make_unique                          201304L
+# define __cpp_lib_null_iterators                       201304L
+# define __cpp_lib_quoted_string_io                     201304L
+# define __cpp_lib_result_of_sfinae                     201210L
+# define __cpp_lib_robust_nonmodifying_seq_ops          201304L
+# define __cpp_lib_shared_timed_mutex                   201402L
+# define __cpp_lib_string_udls                          201304L
+# define __cpp_lib_transformation_trait_aliases         201304L
+# define __cpp_lib_transparent_operators                201210L
+# define __cpp_lib_tuple_element_t                      201402L
+# define __cpp_lib_tuples_by_type                       201304L
 #endif
 
 #if _LIBCPP_STD_VER > 14
+# if !defined(_LIBCPP_HAS_NO_BUILTIN_ADDRESSOF)
+#   define __cpp_lib_addressof_constexpr                201603L
+# endif
+# define __cpp_lib_allocator_traits_is_always_equal     201411L
+# define __cpp_lib_any                                  201606L
+# define __cpp_lib_apply                                201603L
+# define __cpp_lib_array_constexpr                      201603L
+# define __cpp_lib_as_const                             201510L
 # define __cpp_lib_atomic_is_always_lock_free           201603L
+# define __cpp_lib_bool_constant                        201505L
+// # define __cpp_lib_boyer_moore_searcher                 201603L
+# define __cpp_lib_byte                                 201603L
+# define __cpp_lib_chrono                               201611L
+# define __cpp_lib_clamp                                201603L
+# define __cpp_lib_enable_shared_from_this              201603L
+// # define __cpp_lib_execution                            201603L
 # define __cpp_lib_filesystem                           201703L
+# define __cpp_lib_gcd_lcm                              201606L
+# define __cpp_lib_hardware_interference_size           201703L
+# if defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
+#   define __cpp_lib_has_unique_object_representations  201606L
+# endif
+# define __cpp_lib_hypot                                201603L
+# define __cpp_lib_incomplete_container_elements        201505L
 # define __cpp_lib_invoke                               201411L
-# define __cpp_lib_void_t                               201411L
+# if !defined(_LIBCPP_HAS_NO_IS_AGGREGATE)
+#   define __cpp_lib_is_aggregate                       201703L
+# endif
+# define __cpp_lib_is_invocable                         201703L
+# define __cpp_lib_is_swappable                         201603L
+# define __cpp_lib_launder                              201606L
+# define __cpp_lib_logical_traits                       201510L
+# define __cpp_lib_make_from_tuple                      201606L
+# define __cpp_lib_map_try_emplace                      201411L
+// # define __cpp_lib_math_special_functions               201603L
+// # define __cpp_lib_memory_resource                      201603L
 # define __cpp_lib_node_extract                         201606L
+# define __cpp_lib_nonmember_container_access           201411L
+# define __cpp_lib_not_fn                               201603L
+# define __cpp_lib_optional                             201606L
+// # define __cpp_lib_parallel_algorithm                   201603L
+# define __cpp_lib_raw_memory_algorithms                201606L
+# define __cpp_lib_sample                               201603L
+# define __cpp_lib_scoped_lock                          201703L
+# define __cpp_lib_shared_mutex                         201505L
+// # define __cpp_lib_shared_ptr_arrays                    201611L
+# define __cpp_lib_shared_ptr_weak_type                 201606L
+# define __cpp_lib_string_view                          201606L
+// # define __cpp_lib_to_chars                             201611L
+# undef  __cpp_lib_transparent_operators
+# define __cpp_lib_transparent_operators                201510L
+# define __cpp_lib_type_trait_variable_templates        201510L
+# define __cpp_lib_uncaught_exceptions                  201411L
+# define __cpp_lib_unordered_map_try_emplace            201411L
+# define __cpp_lib_variant                              201606L
+# define __cpp_lib_void_t                               201411L
 #endif
 
 #if _LIBCPP_STD_VER > 17
-#ifndef _LIBCPP_NO_HAS_CHAR8_T
-# define __cpp_lib_char8_t                              201811L
-#endif
-#define  __cpp_lib_erase_if                             201811L
+// # define __cpp_lib_atomic_ref                           201806L
+// # define __cpp_lib_bind_front                           201811L
+// # define __cpp_lib_bit_cast                             201806L
+# if !defined(_LIBCPP_NO_HAS_CHAR8_T)
+#   define __cpp_lib_char8_t                            201811L
+# endif
+// # define __cpp_lib_concepts                             201806L
+// # define __cpp_lib_constexpr_misc                       201811L
+// # define __cpp_lib_constexpr_swap_algorithms            201806L
+// # define __cpp_lib_destroying_delete                    201806L
+# define __cpp_lib_erase_if                             201811L
+// # define __cpp_lib_generic_unordered_lookup             201811L
+// # define __cpp_lib_is_constant_evaluated                201811L
+// # define __cpp_lib_list_remove_return_type              201806L
+// # define __cpp_lib_ranges                               201811L
+// # define __cpp_lib_three_way_comparison                 201711L
 #endif
 
-#endif  // _LIBCPP_VERSIONH
+#endif // _LIBCPP_VERSIONH
diff --git a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
index 24d2f8002..860cbab09 100644
--- a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,30 +7,186 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <algorithm> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <algorithm>
 
-/*  Constant                                    Value
-    __cpp_lib_clamp                             201603L
-    __cpp_lib_constexpr_swap_algorithms         201806L
-    __cpp_lib_parallel_algorithm                201603L
-    __cpp_lib_robust_nonmodifying_seq_ops       201304L
-    __cpp_lib_sample                            201603L
+// Test the feature test macros defined by <algorithm>
 
+/*  Constant                                 Value
+    __cpp_lib_clamp                          201603L [C++17]
+    __cpp_lib_constexpr_swap_algorithms      201806L [C++2a]
+    __cpp_lib_parallel_algorithm             201603L [C++17]
+    __cpp_lib_ranges                         201811L [C++2a]
+    __cpp_lib_robust_nonmodifying_seq_ops    201304L [C++14]
+    __cpp_lib_sample                         201603L [C++17]
 */
 
 #include <algorithm>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <algorithm> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_swap_algorithms
+#   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_parallel_algorithm
+#   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_sample
+#   error "__cpp_lib_sample should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_swap_algorithms
+#   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_parallel_algorithm
+#   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++14"
+# endif
+# if __cpp_lib_robust_nonmodifying_seq_ops != 201304L
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_sample
+#   error "__cpp_lib_sample should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should be defined in c++17"
+# endif
+# if __cpp_lib_clamp != 201603L
+#   error "__cpp_lib_clamp should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_swap_algorithms
+#   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should be defined in c++17"
+#   endif
+#   if __cpp_lib_parallel_algorithm != 201603L
+#     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++17"
+# endif
+# if __cpp_lib_robust_nonmodifying_seq_ops != 201304L
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_sample
+#   error "__cpp_lib_sample should be defined in c++17"
+# endif
+# if __cpp_lib_sample != 201603L
+#   error "__cpp_lib_sample should have the value 201603L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should be defined in c++2a"
+# endif
+# if __cpp_lib_clamp != 201603L
+#   error "__cpp_lib_clamp should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_swap_algorithms
+#     error "__cpp_lib_constexpr_swap_algorithms should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_swap_algorithms != 201806L
+#     error "__cpp_lib_constexpr_swap_algorithms should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_swap_algorithms
+#     error "__cpp_lib_constexpr_swap_algorithms should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should be defined in c++2a"
+#   endif
+#   if __cpp_lib_parallel_algorithm != 201603L
+#     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should be defined in c++2a"
+#   endif
+#   if __cpp_lib_ranges != 201811L
+#     error "__cpp_lib_ranges should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++2a"
+# endif
+# if __cpp_lib_robust_nonmodifying_seq_ops != 201304L
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_sample
+#   error "__cpp_lib_sample should be defined in c++2a"
+# endif
+# if __cpp_lib_sample != 201603L
+#   error "__cpp_lib_sample should have the value 201603L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
index 933730442..8e8174323 100644
--- a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <any> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <any>
 
-/*  Constant                                    Value
-    __cpp_lib_any                               201606L
+// Test the feature test macros defined by <any>
 
+/*  Constant         Value
+    __cpp_lib_any    201606L [C++17]
 */
 
 #include <any>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <any> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_any
+#   error "__cpp_lib_any should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_any
+#   error "__cpp_lib_any should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_any
+#   error "__cpp_lib_any should be defined in c++17"
+# endif
+# if __cpp_lib_any != 201606L
+#   error "__cpp_lib_any should have the value 201606L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_any
+#   error "__cpp_lib_any should be defined in c++2a"
+# endif
+# if __cpp_lib_any != 201606L
+#   error "__cpp_lib_any should have the value 201606L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
index 5d25c628b..75c278581 100644
--- a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,27 +7,99 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <array> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <array>
 
-/*  Constant                                    Value
-    __cpp_lib_array_constexpr                   201603L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <array>
 
+/*  Constant                                Value
+    __cpp_lib_array_constexpr               201603L [C++17]
+    __cpp_lib_constexpr_misc                201811L [C++2a]
+    __cpp_lib_nonmember_container_access    201411L [C++17]
 */
 
 #include <array>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <array> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should be defined in c++17"
+# endif
+# if __cpp_lib_array_constexpr != 201603L
+#   error "__cpp_lib_array_constexpr should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should be defined in c++2a"
+# endif
+# if __cpp_lib_array_constexpr != 201603L
+#   error "__cpp_lib_array_constexpr should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_misc != 201811L
+#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
index 78ee09d2f..4c0b35121 100644
--- a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,48 +7,102 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <atomic> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
 
-/*  Constant                                    Value
-    __cpp_lib_char8_t                           201811L
-    __cpp_lib_atomic_is_always_lock_free        201603L
-    __cpp_lib_atomic_ref                        201806L
+// <atomic>
 
-*/
+// Test the feature test macros defined by <atomic>
 
-// UNSUPPORTED: libcpp-has-no-threads
+/*  Constant                                Value
+    __cpp_lib_atomic_is_always_lock_free    201603L [C++17]
+    __cpp_lib_atomic_ref                    201806L [C++2a]
+    __cpp_lib_char8_t                       201811L [C++2a]
+*/
 
 #include <atomic>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <atomic> are defined.
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_ref
+#   error "__cpp_lib_atomic_ref should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_ref
+#   error "__cpp_lib_atomic_ref should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# ifndef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
+# endif
+# if __cpp_lib_atomic_is_always_lock_free != 201603L
+#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_ref
+#   error "__cpp_lib_atomic_ref should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
+# endif
+# if __cpp_lib_atomic_is_always_lock_free != 201603L
+#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_atomic_ref
+#     error "__cpp_lib_atomic_ref should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_ref != 201806L
+#     error "__cpp_lib_atomic_ref should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_atomic_ref
+#     error "__cpp_lib_atomic_ref should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
-# endif
-#endif
-
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_atomic_is_always_lock_free)
-#  error "__cpp_lib_atomic_is_always_lock_free is not defined"
-# elif __cpp_lib_atomic_is_always_lock_free < 201603L
-#  error "__cpp_lib_atomic_is_always_lock_free has an invalid value"
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
index 5dd7d049a..c3e6a56c6 100644
--- a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <bit> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <bit>
 
-/*  Constant                                    Value
-    __cpp_lib_bit_cast                          201806L
+// Test the feature test macros defined by <bit>
 
+/*  Constant              Value
+    __cpp_lib_bit_cast    201806L [C++2a]
 */
 
 #include <bit>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <bit> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_bit_cast
+#     error "__cpp_lib_bit_cast should be defined in c++2a"
+#   endif
+#   if __cpp_lib_bit_cast != 201806L
+#     error "__cpp_lib_bit_cast should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_bit_cast
+#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
index 1d0a79ec1..f777fff88 100644
--- a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,27 +7,76 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <chrono> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <chrono>
 
-/*  Constant                                    Value
-    __cpp_lib_chrono                            201611L
-    __cpp_lib_chrono_udls                       201304L
+// Test the feature test macros defined by <chrono>
 
+/*  Constant                 Value
+    __cpp_lib_chrono         201611L [C++17]
+    __cpp_lib_chrono_udls    201304L [C++14]
 */
 
 #include <chrono>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <chrono> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should not be defined before c++14"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should be defined in c++14"
+# endif
+# if __cpp_lib_chrono_udls != 201304L
+#   error "__cpp_lib_chrono_udls should have the value 201304L in c++14"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should be defined in c++17"
+# endif
+# if __cpp_lib_chrono != 201611L
+#   error "__cpp_lib_chrono should have the value 201611L in c++17"
+# endif
+
+# ifndef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should be defined in c++17"
+# endif
+# if __cpp_lib_chrono_udls != 201304L
+#   error "__cpp_lib_chrono_udls should have the value 201304L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should be defined in c++2a"
+# endif
+# if __cpp_lib_chrono != 201611L
+#   error "__cpp_lib_chrono should have the value 201611L in c++2a"
+# endif
+
+# ifndef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should be defined in c++2a"
+# endif
+# if __cpp_lib_chrono_udls != 201304L
+#   error "__cpp_lib_chrono_udls should have the value 201304L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
index b5b0309f8..02c7c00a5 100644
--- a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,27 +7,85 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <cmath> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <cmath>
 
-/*  Constant                                    Value
-    __cpp_lib_hypot                             201603L
-    __cpp_lib_math_special_functions            201603L
+// Test the feature test macros defined by <cmath>
 
+/*  Constant                            Value
+    __cpp_lib_hypot                     201603L [C++17]
+    __cpp_lib_math_special_functions    201603L [C++17]
 */
 
 #include <cmath>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <cmath> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_math_special_functions
+#   error "__cpp_lib_math_special_functions should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_math_special_functions
+#   error "__cpp_lib_math_special_functions should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should be defined in c++17"
+# endif
+# if __cpp_lib_hypot != 201603L
+#   error "__cpp_lib_hypot should have the value 201603L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should be defined in c++17"
+#   endif
+#   if __cpp_lib_math_special_functions != 201603L
+#     error "__cpp_lib_math_special_functions should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should be defined in c++2a"
+# endif
+# if __cpp_lib_hypot != 201603L
+#   error "__cpp_lib_hypot should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should be defined in c++2a"
+#   endif
+#   if __cpp_lib_math_special_functions != 201603L
+#     error "__cpp_lib_math_special_functions should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
index eff2cb293..e2d8ab88b 100644
--- a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
@@ -7,26 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <new> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
 
-/*  Constant                                    Value
-    __cpp_lib_three_way_comparison              201711L
+// <compare>
 
+// Test the feature test macros defined by <compare>
+
+/*  Constant                          Value
+    __cpp_lib_three_way_comparison    201711L [C++2a]
 */
 
 #include <compare>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <compare> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_three_way_comparison
+#   error "__cpp_lib_three_way_comparison should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_three_way_comparison
+#   error "__cpp_lib_three_way_comparison should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_three_way_comparison
+#   error "__cpp_lib_three_way_comparison should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_three_way_comparison
+#     error "__cpp_lib_three_way_comparison should be defined in c++2a"
+#   endif
+#   if __cpp_lib_three_way_comparison != 201711L
+#     error "__cpp_lib_three_way_comparison should have the value 201711L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_three_way_comparison
+#     error "__cpp_lib_three_way_comparison should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
index be25d793d..889aea0fc 100644
--- a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <complex> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <complex>
 
-/*  Constant                                    Value
-    __cpp_lib_complex_udls                      201309L
+// Test the feature test macros defined by <complex>
 
+/*  Constant                  Value
+    __cpp_lib_complex_udls    201309L [C++14]
 */
 
 #include <complex>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <complex> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should not be defined before c++14"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifndef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should be defined in c++14"
+# endif
+# if __cpp_lib_complex_udls != 201309L
+#   error "__cpp_lib_complex_udls should have the value 201309L in c++14"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should be defined in c++17"
+# endif
+# if __cpp_lib_complex_udls != 201309L
+#   error "__cpp_lib_complex_udls should have the value 201309L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should be defined in c++2a"
+# endif
+# if __cpp_lib_complex_udls != 201309L
+#   error "__cpp_lib_complex_udls should have the value 201309L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
index ad743b51e..55a16288b 100644
--- a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <cstddef> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <cstddef>
 
-/*  Constant                                    Value
-    __cpp_lib_byte                              201603L
+// Test the feature test macros defined by <cstddef>
 
+/*  Constant          Value
+    __cpp_lib_byte    201603L [C++17]
 */
 
 #include <cstddef>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <cstddef> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_byte
+#   error "__cpp_lib_byte should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_byte
+#   error "__cpp_lib_byte should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_byte
+#   error "__cpp_lib_byte should be defined in c++17"
+# endif
+# if __cpp_lib_byte != 201603L
+#   error "__cpp_lib_byte should have the value 201603L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_byte
+#   error "__cpp_lib_byte should be defined in c++2a"
+# endif
+# if __cpp_lib_byte != 201603L
+#   error "__cpp_lib_byte should have the value 201603L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
index 188d2f3c0..94cb8290b 100644
--- a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,38 +7,93 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <deque> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <deque>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <deque>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <deque>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <deque> are defined.
-
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
index 3ea235bdb..25a7c3852 100644
--- a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <exception> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <exception>
 
-/*  Constant                                    Value
-    __cpp_lib_uncaught_exceptions               201411L
+// Test the feature test macros defined by <exception>
 
+/*  Constant                         Value
+    __cpp_lib_uncaught_exceptions    201411L [C++17]
 */
 
 #include <exception>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <exception> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should be defined in c++17"
+# endif
+# if __cpp_lib_uncaught_exceptions != 201411L
+#   error "__cpp_lib_uncaught_exceptions should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should be defined in c++2a"
+# endif
+# if __cpp_lib_uncaught_exceptions != 201411L
+#   error "__cpp_lib_uncaught_exceptions should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
index 4d03634c2..9bd9f08fc 100644
--- a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,45 +7,76 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <filesystem> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <filesystem>
 
-/*  Constant                                    Value
-    __cpp_lib_char8_t                           201811L
-    __cpp_lib_filesystem                        201703L
+// Test the feature test macros defined by <filesystem>
 
+/*  Constant                Value
+    __cpp_lib_char8_t       201811L [C++2a]
+    __cpp_lib_filesystem    201703L [C++17]
 */
 
 #include <filesystem>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <filesystem> are defined.
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should be defined in c++17"
+# endif
+# if __cpp_lib_filesystem != 201703L
+#   error "__cpp_lib_filesystem should have the value 201703L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
-# endif
-#endif
-
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_filesystem)
-#  error "__cpp_lib_filesystem is not defined"
-# elif __cpp_lib_filesystem < 201703L
-#  error "__cpp_lib_filesystem has an invalid value"
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should be defined in c++2a"
+# endif
+# if __cpp_lib_filesystem != 201703L
+#   error "__cpp_lib_filesystem should have the value 201703L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
index 9b44f6e2c..41e4b7749 100644
--- a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,40 +7,142 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <forward_list> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <forward_list>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_incomplete_container_elements     201505L
-    __cpp_lib_list_remove_return_type           201806L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <forward_list>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_incomplete_container_elements       201505L [C++17]
+    __cpp_lib_list_remove_return_type             201806L [C++2a]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <forward_list>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <forward_list> are defined.
-
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++17"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_list_remove_return_type
+#     error "__cpp_lib_list_remove_return_type should be defined in c++2a"
+#   endif
+#   if __cpp_lib_list_remove_return_type != 201806L
+#     error "__cpp_lib_list_remove_return_type should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_list_remove_return_type
+#     error "__cpp_lib_list_remove_return_type should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
index 57978cbb3..4958d4d4c 100644
--- a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,38 +7,239 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <functional> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <functional>
 
-/*  Constant                                    Value
-    __cpp_lib_boyer_moore_searcher              201603L
-    __cpp_lib_invoke                            201411L
-    __cpp_lib_not_fn                            201603L
-    __cpp_lib_result_of_sfinae                  201210L
-    __cpp_lib_transparent_operators             201510L
+// Test the feature test macros defined by <functional>
 
+/*  Constant                           Value
+    __cpp_lib_bind_front               201811L [C++2a]
+    __cpp_lib_boyer_moore_searcher     201603L [C++17]
+    __cpp_lib_constexpr_misc           201811L [C++2a]
+    __cpp_lib_invoke                   201411L [C++17]
+    __cpp_lib_not_fn                   201603L [C++17]
+    __cpp_lib_ranges                   201811L [C++2a]
+    __cpp_lib_result_of_sfinae         201210L [C++14]
+    __cpp_lib_transparent_operators    201210L [C++14]
+                                       201510L [C++17]
 */
 
 #include <functional>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <functional> are defined.
+#if TEST_STD_VER < 14
 
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_invoke)
-#  error "__cpp_lib_invoke is not defined"
-# elif __cpp_lib_invoke < 201411L
-#  error "__cpp_lib_invoke has an invalid value"
+# ifdef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should not be defined before c++2a"
 # endif
-#endif
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_boyer_moore_searcher
+#   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should not be defined before c++14"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_boyer_moore_searcher
+#   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++14"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++14"
+# endif
+
+# ifndef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should be defined in c++14"
+# endif
+# if __cpp_lib_transparent_operators != 201210L
+#   error "__cpp_lib_transparent_operators should have the value 201210L in c++14"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should not be defined before c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should be defined in c++17"
+#   endif
+#   if __cpp_lib_boyer_moore_searcher != 201603L
+#     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should be defined in c++17"
+# endif
+# if __cpp_lib_invoke != 201411L
+#   error "__cpp_lib_invoke should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should be defined in c++17"
+# endif
+# if __cpp_lib_not_fn != 201603L
+#   error "__cpp_lib_not_fn should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++17"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++17"
+# endif
+
+# ifndef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should be defined in c++17"
+# endif
+# if __cpp_lib_transparent_operators != 201510L
+#   error "__cpp_lib_transparent_operators should have the value 201510L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_bind_front
+#     error "__cpp_lib_bind_front should be defined in c++2a"
+#   endif
+#   if __cpp_lib_bind_front != 201811L
+#     error "__cpp_lib_bind_front should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_bind_front
+#     error "__cpp_lib_bind_front should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should be defined in c++2a"
+#   endif
+#   if __cpp_lib_boyer_moore_searcher != 201603L
+#     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_misc != 201811L
+#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should be defined in c++2a"
+# endif
+# if __cpp_lib_invoke != 201411L
+#   error "__cpp_lib_invoke should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should be defined in c++2a"
+# endif
+# if __cpp_lib_not_fn != 201603L
+#   error "__cpp_lib_not_fn should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should be defined in c++2a"
+#   endif
+#   if __cpp_lib_ranges != 201811L
+#     error "__cpp_lib_ranges should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++2a"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++2a"
+# endif
+
+# ifndef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should be defined in c++2a"
+# endif
+# if __cpp_lib_transparent_operators != 201510L
+#   error "__cpp_lib_transparent_operators should have the value 201510L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
new file mode 100755
index 000000000..d51df4543
--- /dev/null
+++ b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
@@ -0,0 +1,959 @@
+#!/usr/bin/env python
+
+import os
+import tempfile
+
+def get_libcxx_paths():
+  script_path = os.path.dirname(os.path.abspath(__file__))
+  assert os.path.exists(script_path)
+  depth = 5
+  src_root = script_path
+  for _ in xrange(0, 5):
+    src_root = os.path.dirname(src_root)
+  include_path = os.path.join(src_root, 'include')
+  assert os.path.exists(include_path)
+  docs_path = os.path.join(src_root, 'docs')
+  assert os.path.exists(docs_path)
+  return script_path, src_root, include_path, docs_path
+
+
+script_path, source_root, include_path, docs_path = get_libcxx_paths()
+
+def has_header(h):
+  h_path = os.path.join(include_path, h)
+  return os.path.exists(h_path)
+
+def add_version_header(tc):
+    tc["headers"].append("version")
+    return tc
+
+feature_test_macros = sorted([ add_version_header(x) for x in [
+  # C++14 macros
+  {"name": "__cpp_lib_integer_sequence",
+   "values": {
+      "c++14": 201304L
+    },
+    "headers": ["utility"],
+  },
+  {"name": "__cpp_lib_exchange_function",
+   "values": {
+     "c++14": 201304L
+   },
+   "headers": ["utility"],
+  },
+  {"name": "__cpp_lib_tuples_by_type",
+   "values": {
+     "c++14": 201304L
+   },
+   "headers": ["utility", "tuple"],
+  },
+  {"name": "__cpp_lib_tuple_element_t",
+   "values": {
+     "c++14": 201402L
+   },
+   "headers": ["tuple"],
+  },
+  {"name": "__cpp_lib_make_unique",
+   "values": {
+     "c++14": 201304L
+   },
+   "headers": ["memory"],
+  },
+  {"name": "__cpp_lib_transparent_operators",
+   "values": {
+     "c++14": 201210L,
+     "c++17": 201510L,
+   },
+   "headers": ["functional"],
+  },
+  {"name": "__cpp_lib_integral_constant_callable",
+   "values": {
+     "c++14": 201304L
+   },
+   "headers": ["type_traits"],
+  },
+  {"name": "__cpp_lib_transformation_trait_aliases",
+   "values": {
+     "c++14": 201304L,
+   },
+   "headers": ["type_traits"]
+  },
+  {"name": "__cpp_lib_result_of_sfinae",
+   "values": {
+     "c++14": 201210L,
+   },
+   "headers": ["functional", "type_traits"]
+  },
+  {"name": "__cpp_lib_is_final",
+   "values": {
+     "c++14": 201402L,
+   },
+   "headers": ["type_traits"]
+  },
+  {"name": "__cpp_lib_is_null_pointer",
+   "values": {
+     "c++14": 201309L,
+   },
+   "headers": ["type_traits"]
+  },
+  {"name": "__cpp_lib_chrono_udls",
+   "values": {
+     "c++14": 201304L,
+   },
+   "headers": ["chrono"]
+  },
+  {"name": "__cpp_lib_string_udls",
+   "values": {
+     "c++14": 201304L,
+   },
+   "headers": ["string"]
+  },
+  {"name": "__cpp_lib_generic_associative_lookup",
+   "values": {
+     "c++14": 201304L,
+   },
+   "headers": ["map", "set"]
+  },
+  {"name": "__cpp_lib_null_iterators",
+   "values": {
+     "c++14": 201304L,
+   },
+   "headers": ["iterator"]
+  },
+  {"name": "__cpp_lib_make_reverse_iterator",
+   "values": {
+     "c++14": 201402L,
+   },
+   "headers": ["iterator"]
+  },
+  {"name": "__cpp_lib_robust_nonmodifying_seq_ops",
+   "values": {
+     "c++14": 201304L,
+   },
+   "headers": ["algorithm"]
+  },
+  {"name": "__cpp_lib_complex_udls",
+   "values": {
+     "c++14": 201309L,
+   },
+   "headers": ["complex"]
+  },
+  {"name": "__cpp_lib_quoted_string_io",
+   "values": {
+     "c++14": 201304L,
+   },
+   "headers": ["iomanip"]
+  },
+  {"name": "__cpp_lib_shared_timed_mutex",
+   "values": {
+     "c++14": 201402L,
+   },
+   "headers": ["shared_mutex"]
+  },
+  # C++17 macros
+  {"name": "__cpp_lib_atomic_is_always_lock_free",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["atomic"]
+  },
+  {"name": "__cpp_lib_filesystem",
+   "values": {
+     "c++17": 201703L,
+   },
+   "headers": ["filesystem"]
+  },
+  {"name": "__cpp_lib_invoke",
+   "values": {
+     "c++17": 201411L,
+   },
+   "headers": ["functional"]
+  },
+  {"name": "__cpp_lib_void_t",
+   "values": {
+     "c++17": 201411L,
+   },
+   "headers": ["type_traits"]
+  },
+  {"name": "__cpp_lib_node_extract",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["map", "set", "unordered_map", "unordered_set"]
+  },
+  {"name": "__cpp_lib_byte",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["cstddef"],
+   },
+  {"name": "__cpp_lib_hardware_interference_size",
+   "values": {
+     "c++17": 201703L,
+   },
+   "headers": ["new"],
+   },
+  {"name": "__cpp_lib_launder",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["new"],
+   },
+  {"name": "__cpp_lib_uncaught_exceptions",
+   "values": {
+     "c++17": 201411L,
+   },
+   "headers": ["exception"],
+   },
+  {"name": "__cpp_lib_as_const",
+   "values": {
+     "c++17": 201510L,
+   },
+   "headers": ["utility"],
+   },
+  {"name": "__cpp_lib_make_from_tuple",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["tuple"],
+   },
+  {"name": "__cpp_lib_apply",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["tuple"],
+   },
+  {"name": "__cpp_lib_optional",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["optional"],
+   },
+  {"name": "__cpp_lib_variant",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["variant"],
+   },
+  {"name": "__cpp_lib_any",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["any"],
+   },
+  {"name": "__cpp_lib_addressof_constexpr",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["memory"],
+   "depends": "TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_BUILTIN_ADDRESSOF)",
+   },
+  {"name": "__cpp_lib_raw_memory_algorithms",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["memory"],
+   },
+  {"name": "__cpp_lib_enable_shared_from_this",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["memory"],
+   },
+  {"name": "__cpp_lib_shared_ptr_weak_type",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["memory"],
+   },
+  {"name": "__cpp_lib_shared_ptr_arrays",
+   "values": {
+     "c++17": 201611L,
+   },
+   "headers": ["memory"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_memory_resource",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["memory_resource"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_boyer_moore_searcher",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["functional"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_not_fn",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["functional"],
+   },
+  {"name": "__cpp_lib_bool_constant",
+   "values": {
+     "c++17": 201505L,
+   },
+   "headers": ["type_traits"],
+   },
+  {"name": "__cpp_lib_type_trait_variable_templates",
+   "values": {
+     "c++17": 201510L,
+   },
+   "headers": ["type_traits"],
+   },
+  {"name": "__cpp_lib_logical_traits",
+   "values": {
+     "c++17": 201510L,
+   },
+   "headers": ["type_traits"],
+   },
+  {"name": "__cpp_lib_is_swappable",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["type_traits"],
+   },
+  {"name": "__cpp_lib_is_invocable",
+   "values": {
+     "c++17": 201703L,
+   },
+   "headers": ["type_traits"],
+   },
+  {"name": "__cpp_lib_has_unique_object_representations",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["type_traits"],
+   "depends": "TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700",
+   "internal_depends": "defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS)",
+   },
+  {"name": "__cpp_lib_is_aggregate",
+   "values": {
+     "c++17": 201703L,
+   },
+   "headers": ["type_traits"],
+   "depends": "TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_IS_AGGREGATE)",
+   },
+  {"name": "__cpp_lib_chrono",
+   "values": {
+     "c++17": 201611L,
+   },
+   "headers": ["chrono"],
+   },
+  {"name": "__cpp_lib_execution",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["execution"],
+   "unimplemented": True
+   },
+  {"name": "__cpp_lib_parallel_algorithm",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["algorithm", "numeric"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_to_chars",
+   "values": {
+     "c++17": 201611L,
+   },
+   "headers": ["utility"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_string_view",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["string", "string_view"],
+   },
+  {"name": "__cpp_lib_allocator_traits_is_always_equal",
+   "values": {
+     "c++17": 201411L,
+   },
+   "headers": ["memory", "scoped_allocator", "string", "deque", "forward_list", "list", "vector", "map", "set", "unordered_map", "unordered_set"],
+   },
+  {"name": "__cpp_lib_incomplete_container_elements",
+   "values": {
+     "c++17": 201505L,
+   },
+   "headers": ["forward_list", "list", "vector"],
+   },
+  {"name": "__cpp_lib_map_try_emplace",
+   "values": {
+     "c++17": 201411L,
+   },
+   "headers": ["map"],
+   },
+  {"name": "__cpp_lib_unordered_map_try_emplace",
+   "values": {
+     "c++17": 201411L,
+   },
+   "headers": ["unordered_map"],
+   },
+  {"name": "__cpp_lib_array_constexpr",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["iterator", "array"],
+   },
+  {"name": "__cpp_lib_nonmember_container_access",
+   "values": {
+     "c++17": 201411L,
+   },
+   "headers": ["iterator", "array", "deque", "forward_list", "list", "map", "regex",
+               "set", "string", "unordered_map", "unordered_set", "vector"],
+   },
+  {"name": "__cpp_lib_sample",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["algorithm"],
+   },
+  {"name": "__cpp_lib_clamp",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["algorithm"],
+   },
+  {"name": "__cpp_lib_gcd_lcm",
+   "values": {
+     "c++17": 201606L,
+   },
+   "headers": ["numeric"],
+   },
+  {"name": "__cpp_lib_hypot",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["cmath"],
+   },
+  {"name": "__cpp_lib_math_special_functions",
+   "values": {
+     "c++17": 201603L,
+   },
+   "headers": ["cmath"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_shared_mutex",
+   "values": {
+     "c++17": 201505L,
+   },
+   "headers": ["shared_mutex"],
+   },
+  {"name": "__cpp_lib_scoped_lock",
+   "values": {
+     "c++17": 201703L,
+   },
+   "headers": ["mutex"],
+   },
+  # C++2a
+  {"name": "__cpp_lib_char8_t",
+   "values": {
+     "c++2a": 201811L,
+   },
+   "headers": ["atomic", "filesystem", "istream", "limits", "locale", "ostream",
+               "string", "string_view"],
+   "depends": "defined(__cpp_char8_t)",
+   "internal_depends": "!defined(_LIBCPP_NO_HAS_CHAR8_T)",
+   },
+  {"name": "__cpp_lib_erase_if",
+   "values": {
+     "c++2a": 201811L,
+   },
+   "headers": ["string", "deque", "forward_list", "list", "vector", "map",
+               "set", "unordered_map", "unordered_set"]
+  },
+  {"name": "__cpp_lib_destroying_delete",
+   "values": {
+     "c++2a": 201806L,
+   },
+   "headers": ["new"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_three_way_comparison",
+   "values": {
+     "c++2a": 201711L,
+   },
+   "headers": ["compare"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_concepts",
+   "values": {
+     "c++2a": 201806L,
+   },
+   "headers": ["concepts"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_constexpr_swap_algorithms",
+   "values": {
+     "c++2a": 201806L,
+   },
+   "headers": ["algorithm"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_constexpr_misc",
+   "values": {
+     "c++2a": 201811L,
+   },
+   "headers": ["array", "functional", "iterator", "string_view", "tuple", "utility"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_bind_front",
+   "values": {
+     "c++2a": 201811L,
+   },
+   "headers": ["functional"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_is_constant_evaluated",
+   "values": {
+     "c++2a": 201811L,
+   },
+   "headers": ["type_traits"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_list_remove_return_type",
+   "values": {
+     "c++2a": 201806L,
+   },
+   "headers": ["forward_list", "list"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_generic_unordered_lookup",
+   "values": {
+     "c++2a": 201811L,
+   },
+   "headers": ["unordered_map", "unordered_set"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_ranges",
+   "values": {
+     "c++2a": 201811L,
+   },
+   "headers": ["algorithm", "functional", "iterator", "memory", "ranges"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_bit_cast",
+   "values": {
+     "c++2a": 201806L,
+   },
+   "headers": ["bit"],
+   "unimplemented": True,
+   },
+  {"name": "__cpp_lib_atomic_ref",
+   "values": {
+     "c++2a": 201806L,
+   },
+   "headers": ["atomic"],
+   "unimplemented": True,
+   },
+]], key=lambda tc: tc["name"])
+
+def get_std_dialects():
+  std_dialects = ['c++14', 'c++17', 'c++2a']
+  return list(std_dialects)
+
+def get_first_std(d):
+    for s in get_std_dialects():
+        if s in d.keys():
+            return s
+    return None
+
+def get_last_std(d):
+  rev_dialects = get_std_dialects()
+  rev_dialects.reverse()
+  for s in rev_dialects:
+    if s in d.keys():
+      return s
+  return None
+
+def get_std_before(d, std):
+  std_dialects = get_std_dialects()
+  candidates = std_dialects[0:std_dialects.index(std)]
+  candidates.reverse()
+  for cand in candidates:
+    if cand in d.keys():
+      return cand
+  return None
+
+def get_value_before(d, std):
+  new_std = get_std_before(d, std)
+  if new_std is None:
+    return None
+  return d[new_std]
+
+def get_for_std(d, std):
+  # This catches the C++11 case for which there should be no defined feature
+  # test macros.
+  std_dialects = get_std_dialects()
+  if std not in std_dialects:
+    return None
+  # Find the value for the newest C++ dialect between C++14 and std
+  std_list = list(std_dialects[0:std_dialects.index(std)+1])
+  std_list.reverse()
+  for s in std_list:
+    if s in d.keys():
+      return d[s]
+  return None
+
+
+"""
+  Functions to produce the <version> header
+"""
+
+def produce_macros_definition_for_std(std):
+  result = ""
+  indent = 56
+  for tc in feature_test_macros:
+    if std not in tc["values"]:
+      continue
+    inner_indent = 1
+    if 'depends' in tc.keys():
+      assert 'internal_depends' in tc.keys()
+      result += "# if %s\n" % tc["internal_depends"]
+      inner_indent += 2
+    if get_value_before(tc["values"], std) is not None:
+      assert 'depends' not in tc.keys()
+      result += "# undef  %s\n" % tc["name"]
+    line = "#%sdefine %s" % ((" " * inner_indent), tc["name"])
+    line += " " * (indent - len(line))
+    line += "%sL" % tc["values"][std]
+    if 'unimplemented' in tc.keys():
+      line = "// " + line
+    result += line
+    result += "\n"
+    if 'depends' in tc.keys():
+      result += "# endif\n"
+  return result
+
+def chunks(l, n):
+  """Yield successive n-sized chunks from l."""
+  for i in range(0, len(l), n):
+    yield l[i:i + n]
+
+def produce_version_synopsis():
+  indent = 56
+  header_indent = 56 + len("20XXYYL ")
+  result = ""
+  def indent_to(s, val):
+    if len(s) >= val:
+      return s
+    s += " " * (val - len(s))
+    return s
+  line = indent_to("Macro name", indent) + "Value"
+  line = indent_to(line, header_indent) + "Headers"
+  result += line + "\n"
+  for tc in feature_test_macros:
+    prev_defined_std = get_last_std(tc["values"])
+    line = "{name: <{indent}}{value}L ".format(name=tc['name'], indent=indent,
+                                               value=tc["values"][prev_defined_std])
+    headers = list(tc["headers"])
+    headers.remove("version")
+    for chunk in chunks(headers, 3):
+      line = indent_to(line, header_indent)
+      chunk = ['<%s>' % header for header in chunk]
+      line += ' '.join(chunk)
+      result += line
+      result += "\n"
+      line = ""
+    while True:
+      prev_defined_std = get_std_before(tc["values"], prev_defined_std)
+      if prev_defined_std is None:
+        break
+      result += "%s%sL // %s\n" % (indent_to("", indent), tc["values"][prev_defined_std],
+                                prev_defined_std.replace("c++", "C++"))
+  return result
+
+
+def produce_version_header():
+  template="""// -*- C++ -*-
+//===--------------------------- version ----------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_VERSIONH
+#define _LIBCPP_VERSIONH
+
+/*
+  version synopsis
+
+{synopsis}
+
+*/
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 11
+{cxx14_macros}
+#endif
+
+#if _LIBCPP_STD_VER > 14
+{cxx17_macros}
+#endif
+
+#if _LIBCPP_STD_VER > 17
+{cxx2a_macros}
+#endif
+
+#endif // _LIBCPP_VERSIONH
+"""
+  return template.format(
+      synopsis=produce_version_synopsis().strip(),
+      cxx14_macros=produce_macros_definition_for_std('c++14').strip(),
+      cxx17_macros=produce_macros_definition_for_std('c++17').strip(),
+      cxx2a_macros=produce_macros_definition_for_std('c++2a').strip())
+
+"""
+    Functions to produce test files
+"""
+
+test_types = {
+  "undefined": """
+# ifdef {name}
+#   error "{name} should not be defined before {std_first}"
+# endif
+""",
+
+  "depends": """
+# if {depends}
+#   ifndef {name}
+#     error "{name} should be defined in {std}"
+#   endif
+#   if {name} != {value}
+#     error "{name} should have the value {value} in {std}"
+#   endif
+# else
+#   ifdef {name}
+#     error "{name} should not be defined when {depends} is not defined!"
+#   endif
+# endif
+""",
+
+  "unimplemented": """
+# if !defined(_LIBCPP_VERSION)
+#   ifndef {name}
+#     error "{name} should be defined in {std}"
+#   endif
+#   if {name} != {value}
+#     error "{name} should have the value {value} in {std}"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef {name}
+#     error "{name} should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+""",
+
+  "defined":"""
+# ifndef {name}
+#   error "{name} should be defined in {std}"
+# endif
+# if {name} != {value}
+#   error "{name} should have the value {value} in {std}"
+# endif
+"""
+}
+
+def generate_std_test(test_list, std):
+  result = ""
+  for tc in test_list:
+    val = get_for_std(tc["values"], std)
+    if val is not None:
+      val = "%sL" % val
+    if val is None:
+      result += test_types["undefined"].format(name=tc["name"], std_first=get_first_std(tc["values"]))
+    elif 'unimplemented' in tc.keys():
+      result += test_types["unimplemented"].format(name=tc["name"], value=val, std=std)
+    elif "depends" in tc.keys():
+      result += test_types["depends"].format(name=tc["name"], value=val, std=std, depends=tc["depends"])
+    else:
+      result +=  test_types["defined"].format(name=tc["name"], value=val, std=std)
+  return result
+
+def generate_synopsis(test_list):
+    max_name_len = max([len(tc["name"]) for tc in test_list])
+    indent = max_name_len + 8
+    def mk_line(prefix, suffix):
+        return "{prefix: <{max_len}}{suffix}\n".format(prefix=prefix, suffix=suffix,
+        max_len=indent)
+    result = ""
+    result += mk_line("/*  Constant", "Value")
+    for tc in test_list:
+        prefix = "    %s" % tc["name"]
+        for std in [s for s in get_std_dialects() if s in tc["values"].keys()]:
+            result += mk_line(prefix, "%sL [%s]" % (tc["values"][std], std.replace("c++", "C++")))
+            prefix = ""
+    result += "*/"
+    return result
+
+def produce_tests():
+  headers = set([h for tc in feature_test_macros for h in tc["headers"]])
+  for h in headers:
+    test_list = [tc for tc in feature_test_macros if h in tc["headers"]]
+    if not has_header(h):
+      for tc in test_list:
+        assert 'unimplemented' in tc.keys()
+      continue
+    test_body = \
+"""//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <{header}>
+
+// Test the feature test macros defined by <{header}>
+
+{synopsis}
+
+#include <{header}>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+{cxx11_tests}
+
+#elif TEST_STD_VER == 14
+
+{cxx14_tests}
+
+#elif TEST_STD_VER == 17
+
+{cxx17_tests}
+
+#elif TEST_STD_VER > 17
+
+{cxx2a_tests}
+
+#endif // TEST_STD_VER > 17
+
+int main() {{}}
+""".format(header=h,
+           synopsis=generate_synopsis(test_list),
+           cxx11_tests=generate_std_test(test_list, 'c++11').strip(),
+           cxx14_tests=generate_std_test(test_list, 'c++14').strip(),
+           cxx17_tests=generate_std_test(test_list, 'c++17').strip(),
+           cxx2a_tests=generate_std_test(test_list, 'c++2a').strip())
+    test_name = "{header}.version.pass.cpp".format(header=h)
+    out_path = os.path.join(script_path, test_name)
+    with open(out_path, 'w') as f:
+      f.write(test_body)
+
+"""
+    Produce documentation for the feature test macros
+"""
+
+def make_widths(grid):
+  widths = []
+  for i in range(0, len(grid[0])):
+    cell_width = 2 + max(reduce(lambda x,y: x+y, [[len(row[i])] for row in grid], []))
+    widths += [cell_width]
+  return widths
+
+def create_table(grid, indent):
+  indent_str = ' '*indent
+  col_widths = make_widths(grid)
+  num_cols = len(grid[0])
+  result = indent_str + add_divider(col_widths, 2)
+  header_flag = 2
+  for row_i in xrange(0, len(grid)):
+    row = grid[row_i]
+    result = result + indent_str + ' '.join([pad_cell(row[i], col_widths[i]) for i in range(0, len(row))]) + '\n'
+    is_cxx_header = row[0].startswith('**')
+    if row_i == len(grid) - 1:
+      header_flag = 2
+    result = result + indent_str + add_divider(col_widths, 1 if is_cxx_header else header_flag)
+    header_flag = 0
+  return result
+
+def add_divider(widths, header_flag):
+  if header_flag == 2:
+    return ' '.join(['='*w for w in widths]) + '\n'
+  if header_flag == 1:
+    return '-'.join(['-'*w for w in widths]) + '\n'
+  else:
+    return ' '.join(['-'*w for w in widths]) + '\n'
+
+def pad_cell(s, length, left_align=True):
+  padding = ((length - len(s)) * ' ')
+  return s + padding
+
+
+def get_status_table():
+  table = [["Macro Name", "Value"]]
+  for std in get_std_dialects():
+    table += [["**" + std.replace("c++", "C++ ") + "**", ""]]
+    for tc in feature_test_macros:
+      if std not in tc["values"].keys():
+        continue
+      value = "``%sL``" % tc["values"][std]
+      if 'unimplemented' in tc.keys():
+        value = '*unimplemented*'
+      table += [["``%s``" % tc["name"], value]]
+  return table
+
+def produce_docs():
+  doc_str = """.. _FeatureTestMacroTable:
+
+==========================
+Feature Test Macro Support
+==========================
+
+.. contents::
+   :local:
+
+Overview
+========
+
+This file documents the feature test macros currently supported by libc++.
+
+.. _feature-status:
+
+Status
+======
+
+.. table:: Current Status
+     :name: feature-status-table
+     :widths: auto
+     
+{status_tables}
+
+""".format(status_tables=create_table(get_status_table(), 4))
+
+  table_doc_path = os.path.join(docs_path, 'FeatureTestMacroTable.rst')
+  with open(table_doc_path, 'w') as f:
+    f.write(doc_str)
+
+def main():
+  with tempfile.NamedTemporaryFile(mode='w', prefix='version.', delete=False) as tmp_file:
+    print("producing new <version> header as %s" % tmp_file.name)
+    tmp_file.write(produce_version_header())
+  produce_tests()
+  produce_docs()
+
+
+if __name__ == '__main__':
+  main()
diff --git a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
index 74ab48e3c..f82e5ba04 100644
--- a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <iomanip> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <iomanip>
 
-/*  Constant                                    Value
-    __cpp_lib_quoted_string_io                  201304L
+// Test the feature test macros defined by <iomanip>
 
+/*  Constant                      Value
+    __cpp_lib_quoted_string_io    201304L [C++14]
 */
 
 #include <iomanip>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <iomanip> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should not be defined before c++14"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifndef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should be defined in c++14"
+# endif
+# if __cpp_lib_quoted_string_io != 201304L
+#   error "__cpp_lib_quoted_string_io should have the value 201304L in c++14"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should be defined in c++17"
+# endif
+# if __cpp_lib_quoted_string_io != 201304L
+#   error "__cpp_lib_quoted_string_io should have the value 201304L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should be defined in c++2a"
+# endif
+# if __cpp_lib_quoted_string_io != 201304L
+#   error "__cpp_lib_quoted_string_io should have the value 201304L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
index 7ede323ca..195ca2d0b 100644
--- a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,36 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <istream> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <istream>
 
-/*  Constant                                    Value
-    __cpp_lib_char8_t                           201811L
+// Test the feature test macros defined by <istream>
 
+/*  Constant             Value
+    __cpp_lib_char8_t    201811L [C++2a]
 */
 
 #include <istream>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <istream> are defined.
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
 # endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
index 50c582fd8..7113bd3ae 100644
--- a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,29 +7,177 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <iterator> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <iterator>
 
-/*  Constant                                    Value
-    __cpp_lib_array_constexpr                   201603L
-    __cpp_lib_make_reverse_iterator             201402L
-    __cpp_lib_nonmember_container_access        201411L
-    __cpp_lib_null_iterators                    201304L
+// Test the feature test macros defined by <iterator>
 
+/*  Constant                                Value
+    __cpp_lib_array_constexpr               201603L [C++17]
+    __cpp_lib_constexpr_misc                201811L [C++2a]
+    __cpp_lib_make_reverse_iterator         201402L [C++14]
+    __cpp_lib_nonmember_container_access    201411L [C++17]
+    __cpp_lib_null_iterators                201304L [C++14]
+    __cpp_lib_ranges                        201811L [C++2a]
 */
 
 #include <iterator>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <iterator> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should be defined in c++14"
+# endif
+# if __cpp_lib_make_reverse_iterator != 201402L
+#   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++14"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should be defined in c++14"
+# endif
+# if __cpp_lib_null_iterators != 201304L
+#   error "__cpp_lib_null_iterators should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should be defined in c++17"
+# endif
+# if __cpp_lib_array_constexpr != 201603L
+#   error "__cpp_lib_array_constexpr should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should be defined in c++17"
+# endif
+# if __cpp_lib_make_reverse_iterator != 201402L
+#   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++17"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should be defined in c++17"
+# endif
+# if __cpp_lib_null_iterators != 201304L
+#   error "__cpp_lib_null_iterators should have the value 201304L in c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should be defined in c++2a"
+# endif
+# if __cpp_lib_array_constexpr != 201603L
+#   error "__cpp_lib_array_constexpr should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_misc != 201811L
+#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should be defined in c++2a"
+# endif
+# if __cpp_lib_make_reverse_iterator != 201402L
+#   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should be defined in c++2a"
+# endif
+# if __cpp_lib_null_iterators != 201304L
+#   error "__cpp_lib_null_iterators should have the value 201304L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should be defined in c++2a"
+#   endif
+#   if __cpp_lib_ranges != 201811L
+#     error "__cpp_lib_ranges should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
index 7f1869237..91f0d7ced 100644
--- a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,36 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <limits> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <limits>
 
-/*  Constant                                    Value
-    __cpp_lib_char8_t                           201811L
+// Test the feature test macros defined by <limits>
 
+/*  Constant             Value
+    __cpp_lib_char8_t    201811L [C++2a]
 */
 
 #include <limits>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <limits> are defined.
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
 # endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
index e6e65655b..12e683f26 100644
--- a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,40 +7,142 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <list> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <list>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_incomplete_container_elements     201505L
-    __cpp_lib_list_remove_return_type           201806L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <list>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_incomplete_container_elements       201505L [C++17]
+    __cpp_lib_list_remove_return_type             201806L [C++2a]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <list>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <list> are defined.
-
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++17"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_list_remove_return_type
+#     error "__cpp_lib_list_remove_return_type should be defined in c++2a"
+#   endif
+#   if __cpp_lib_list_remove_return_type != 201806L
+#     error "__cpp_lib_list_remove_return_type should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_list_remove_return_type
+#     error "__cpp_lib_list_remove_return_type should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
index 602273329..e77aa7106 100644
--- a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,36 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <locale> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <locale>
 
-/*  Constant                                    Value
-    __cpp_lib_char8_t                           201811L
+// Test the feature test macros defined by <locale>
 
+/*  Constant             Value
+    __cpp_lib_char8_t    201811L [C++2a]
 */
 
 #include <locale>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <locale> are defined.
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
 # endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
index e7dbf7d20..31ef16061 100644
--- a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,41 +7,165 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <map> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <map>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_generic_associative_lookup        201304L
-    __cpp_lib_map_try_emplace                   201411L
-    __cpp_lib_node_extract                      201606L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <map>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_generic_associative_lookup          201304L [C++14]
+    __cpp_lib_map_try_emplace                     201411L [C++17]
+    __cpp_lib_node_extract                        201606L [C++17]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <map>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <map> are defined.
-
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++14"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++17"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should be defined in c++17"
+# endif
+# if __cpp_lib_map_try_emplace != 201411L
+#   error "__cpp_lib_map_try_emplace should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++17"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++2a"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should be defined in c++2a"
+# endif
+# if __cpp_lib_map_try_emplace != 201411L
+#   error "__cpp_lib_map_try_emplace should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++2a"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
index 4ffb7bd80..4780a1f70 100644
--- a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,33 +7,241 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <memory> feature macros
-
-/*  Constant                                    Value
-    __cpp_lib_addressof_constexpr               201603L
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_enable_shared_from_this           201603L
-    __cpp_lib_make_unique                       201304L
-    __cpp_lib_raw_memory_algorithms             201606L
-    __cpp_lib_shared_ptr_arrays                 201611L
-    __cpp_lib_shared_ptr_weak_type              201606L
-    __cpp_lib_transparent_operators             201510L
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <memory>
+
+// Test the feature test macros defined by <memory>
 
+/*  Constant                                      Value
+    __cpp_lib_addressof_constexpr                 201603L [C++17]
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_enable_shared_from_this             201603L [C++17]
+    __cpp_lib_make_unique                         201304L [C++14]
+    __cpp_lib_ranges                              201811L [C++2a]
+    __cpp_lib_raw_memory_algorithms               201606L [C++17]
+    __cpp_lib_shared_ptr_arrays                   201611L [C++17]
+    __cpp_lib_shared_ptr_weak_type                201606L [C++17]
 */
 
 #include <memory>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <memory> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_addressof_constexpr
+#   error "__cpp_lib_addressof_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_arrays
+#   error "__cpp_lib_shared_ptr_arrays should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_addressof_constexpr
+#   error "__cpp_lib_addressof_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should be defined in c++14"
+# endif
+# if __cpp_lib_make_unique != 201304L
+#   error "__cpp_lib_make_unique should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_arrays
+#   error "__cpp_lib_shared_ptr_arrays should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# if TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should be defined in c++17"
+#   endif
+#   if __cpp_lib_addressof_constexpr != 201603L
+#     error "__cpp_lib_addressof_constexpr should have the value 201603L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should not be defined when TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should be defined in c++17"
+# endif
+# if __cpp_lib_enable_shared_from_this != 201603L
+#   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should be defined in c++17"
+# endif
+# if __cpp_lib_make_unique != 201304L
+#   error "__cpp_lib_make_unique should have the value 201304L in c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should be defined in c++17"
+# endif
+# if __cpp_lib_raw_memory_algorithms != 201606L
+#   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should be defined in c++17"
+#   endif
+#   if __cpp_lib_shared_ptr_arrays != 201611L
+#     error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should be defined in c++17"
+# endif
+# if __cpp_lib_shared_ptr_weak_type != 201606L
+#   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should be defined in c++2a"
+#   endif
+#   if __cpp_lib_addressof_constexpr != 201603L
+#     error "__cpp_lib_addressof_constexpr should have the value 201603L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should not be defined when TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should be defined in c++2a"
+# endif
+# if __cpp_lib_enable_shared_from_this != 201603L
+#   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should be defined in c++2a"
+# endif
+# if __cpp_lib_make_unique != 201304L
+#   error "__cpp_lib_make_unique should have the value 201304L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should be defined in c++2a"
+#   endif
+#   if __cpp_lib_ranges != 201811L
+#     error "__cpp_lib_ranges should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should be defined in c++2a"
+# endif
+# if __cpp_lib_raw_memory_algorithms != 201606L
+#   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should be defined in c++2a"
+#   endif
+#   if __cpp_lib_shared_ptr_arrays != 201611L
+#     error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should be defined in c++2a"
+# endif
+# if __cpp_lib_shared_ptr_weak_type != 201606L
+#   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
index 72209d9f4..e572d5796 100644
--- a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <mutex> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <mutex>
 
-/*  Constant                                    Value
-    __cpp_lib_scoped_lock                       201703L
+// Test the feature test macros defined by <mutex>
 
+/*  Constant                 Value
+    __cpp_lib_scoped_lock    201703L [C++17]
 */
 
 #include <mutex>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <mutex> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should be defined in c++17"
+# endif
+# if __cpp_lib_scoped_lock != 201703L
+#   error "__cpp_lib_scoped_lock should have the value 201703L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should be defined in c++2a"
+# endif
+# if __cpp_lib_scoped_lock != 201703L
+#   error "__cpp_lib_scoped_lock should have the value 201703L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
index 6bcd242d1..beddc6010 100644
--- a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
@@ -7,28 +7,99 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <new> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
 
-/*  Constant                                    Value
-    __cpp_lib_destroying_delete                 201806L
-    __cpp_lib_hardware_interference_size        201703L
-    __cpp_lib_launder                           201606L
+// <new>
 
+// Test the feature test macros defined by <new>
+
+/*  Constant                                Value
+    __cpp_lib_destroying_delete             201806L [C++2a]
+    __cpp_lib_hardware_interference_size    201703L [C++17]
+    __cpp_lib_launder                       201606L [C++17]
 */
 
 #include <new>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <new> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_destroying_delete
+#   error "__cpp_lib_destroying_delete should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_launder
+#   error "__cpp_lib_launder should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_destroying_delete
+#   error "__cpp_lib_destroying_delete should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_launder
+#   error "__cpp_lib_launder should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_destroying_delete
+#   error "__cpp_lib_destroying_delete should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++17"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++17"
+# endif
+
+# ifndef __cpp_lib_launder
+#   error "__cpp_lib_launder should be defined in c++17"
+# endif
+# if __cpp_lib_launder != 201606L
+#   error "__cpp_lib_launder should have the value 201606L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_destroying_delete
+#     error "__cpp_lib_destroying_delete should be defined in c++2a"
+#   endif
+#   if __cpp_lib_destroying_delete != 201806L
+#     error "__cpp_lib_destroying_delete should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_destroying_delete
+#     error "__cpp_lib_destroying_delete should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++2a"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++2a"
+# endif
+
+# ifndef __cpp_lib_launder
+#   error "__cpp_lib_launder should be defined in c++2a"
+# endif
+# if __cpp_lib_launder != 201606L
+#   error "__cpp_lib_launder should have the value 201606L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
index 61547621e..39bab221c 100644
--- a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,27 +7,85 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <numeric> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <numeric>
 
-/*  Constant                                    Value
-    __cpp_lib_gcd_lcm                           201606L
-    __cpp_lib_parallel_algorithm                201603L
+// Test the feature test macros defined by <numeric>
 
+/*  Constant                        Value
+    __cpp_lib_gcd_lcm               201606L [C++17]
+    __cpp_lib_parallel_algorithm    201603L [C++17]
 */
 
 #include <numeric>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <numeric> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_parallel_algorithm
+#   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_parallel_algorithm
+#   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should be defined in c++17"
+# endif
+# if __cpp_lib_gcd_lcm != 201606L
+#   error "__cpp_lib_gcd_lcm should have the value 201606L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should be defined in c++17"
+#   endif
+#   if __cpp_lib_parallel_algorithm != 201603L
+#     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should be defined in c++2a"
+# endif
+# if __cpp_lib_gcd_lcm != 201606L
+#   error "__cpp_lib_gcd_lcm should have the value 201606L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should be defined in c++2a"
+#   endif
+#   if __cpp_lib_parallel_algorithm != 201603L
+#     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
index b9795181a..c7db36f68 100644
--- a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <optional> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <optional>
 
-/*  Constant                                    Value
-    __cpp_lib_optional                          201606L
+// Test the feature test macros defined by <optional>
 
+/*  Constant              Value
+    __cpp_lib_optional    201606L [C++17]
 */
 
 #include <optional>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <optional> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_optional
+#   error "__cpp_lib_optional should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_optional
+#   error "__cpp_lib_optional should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_optional
+#   error "__cpp_lib_optional should be defined in c++17"
+# endif
+# if __cpp_lib_optional != 201606L
+#   error "__cpp_lib_optional should have the value 201606L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_optional
+#   error "__cpp_lib_optional should be defined in c++2a"
+# endif
+# if __cpp_lib_optional != 201606L
+#   error "__cpp_lib_optional should have the value 201606L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
index 668b39e32..724171220 100644
--- a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,36 +7,53 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <ostream> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <ostream>
 
-/*  Constant                                    Value
-    __cpp_lib_char8_t                           201811L
+// Test the feature test macros defined by <ostream>
 
+/*  Constant             Value
+    __cpp_lib_char8_t    201811L [C++2a]
 */
 
 #include <ostream>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <ostream> are defined.
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
 # endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
index fdc499328..9869e209b 100644
--- a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <regex> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <regex>
 
-/*  Constant                                    Value
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <regex>
 
+/*  Constant                                Value
+    __cpp_lib_nonmember_container_access    201411L [C++17]
 */
 
 #include <regex>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <regex> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
index 84b2dbdb2..171fe5e32 100644
--- a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <scoped_allocator> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <scoped_allocator>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
+// Test the feature test macros defined by <scoped_allocator>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
 */
 
 #include <scoped_allocator>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <scoped_allocator> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
index 716eae6d9..95af65c1f 100644
--- a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,40 +7,142 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <set> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <set>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_generic_associative_lookup        201304L
-    __cpp_lib_node_extract                      201606L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <set>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_generic_associative_lookup          201304L [C++14]
+    __cpp_lib_node_extract                        201606L [C++17]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <set>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <set> are defined.
-
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++14"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++17"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++17"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++2a"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++2a"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
index 33387e890..a86aebe70 100644
--- a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,29 +7,76 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <shared_mutex> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
 
-/*  Constant                                    Value
-    __cpp_lib_shared_mutex                      201505L
-    __cpp_lib_shared_timed_mutex                201402L
+// <shared_mutex>
 
-*/
+// Test the feature test macros defined by <shared_mutex>
 
-// UNSUPPORTED: libcpp-has-no-threads
+/*  Constant                        Value
+    __cpp_lib_shared_mutex          201505L [C++17]
+    __cpp_lib_shared_timed_mutex    201402L [C++14]
+*/
 
 #include <shared_mutex>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <shared_mutex> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should not be defined before c++14"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should be defined in c++14"
+# endif
+# if __cpp_lib_shared_timed_mutex != 201402L
+#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++14"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should be defined in c++17"
+# endif
+# if __cpp_lib_shared_mutex != 201505L
+#   error "__cpp_lib_shared_mutex should have the value 201505L in c++17"
+# endif
+
+# ifndef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should be defined in c++17"
+# endif
+# if __cpp_lib_shared_timed_mutex != 201402L
+#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should be defined in c++2a"
+# endif
+# if __cpp_lib_shared_mutex != 201505L
+#   error "__cpp_lib_shared_mutex should have the value 201505L in c++2a"
+# endif
+
+# ifndef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should be defined in c++2a"
+# endif
+# if __cpp_lib_shared_timed_mutex != 201402L
+#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
index 87e8c8f96..dd6d09e24 100644
--- a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,51 +7,168 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <string> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <string>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_char8_t                           201811L
-    __cpp_lib_nonmember_container_access        201411L
-    __cpp_lib_string_udls                       201304L
-    __cpp_lib_string_view                       201606L
+// Test the feature test macros defined by <string>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_char8_t                             201811L [C++2a]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
+    __cpp_lib_string_udls                         201304L [C++14]
+    __cpp_lib_string_view                         201606L [C++17]
 */
 
 #include <string>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <string> are defined.
+#if TEST_STD_VER < 14
 
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should be defined in c++14"
+# endif
+# if __cpp_lib_string_udls != 201304L
+#   error "__cpp_lib_string_udls should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should be defined in c++17"
+# endif
+# if __cpp_lib_string_udls != 201304L
+#   error "__cpp_lib_string_udls should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should be defined in c++17"
+# endif
+# if __cpp_lib_string_view != 201606L
+#   error "__cpp_lib_string_view should have the value 201606L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
-#endif
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should be defined in c++2a"
+# endif
+# if __cpp_lib_string_udls != 201304L
+#   error "__cpp_lib_string_udls should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should be defined in c++2a"
+# endif
+# if __cpp_lib_string_view != 201606L
+#   error "__cpp_lib_string_view should have the value 201606L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
index bbdeb0b5a..c8ceb7c7e 100644
--- a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,37 +7,102 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <string_view> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <string_view>
 
-/*  Constant                                    Value
-    __cpp_lib_char8_t                           201811L
-    __cpp_lib_string_view                       201606L
+// Test the feature test macros defined by <string_view>
 
+/*  Constant                    Value
+    __cpp_lib_char8_t           201811L [C++2a]
+    __cpp_lib_constexpr_misc    201811L [C++2a]
+    __cpp_lib_string_view       201606L [C++17]
 */
 
 #include <string_view>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <string_view> are defined.
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should be defined in c++17"
+# endif
+# if __cpp_lib_string_view != 201606L
+#   error "__cpp_lib_string_view should have the value 201606L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
 # else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_misc != 201811L
+#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should be defined in c++2a"
+# endif
+# if __cpp_lib_string_view != 201606L
+#   error "__cpp_lib_string_view should have the value 201606L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
index ddff29d78..6e680a774 100644
--- a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,29 +7,151 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <tuple> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <tuple>
 
-/*  Constant                                    Value
-    __cpp_lib_apply                             201603L
-    __cpp_lib_make_from_tuple                   201606L
-    __cpp_lib_tuple_element_t                   201402L
-    __cpp_lib_tuples_by_type                    201304L
+// Test the feature test macros defined by <tuple>
 
+/*  Constant                     Value
+    __cpp_lib_apply              201603L [C++17]
+    __cpp_lib_constexpr_misc     201811L [C++2a]
+    __cpp_lib_make_from_tuple    201606L [C++17]
+    __cpp_lib_tuple_element_t    201402L [C++14]
+    __cpp_lib_tuples_by_type     201304L [C++14]
 */
 
 #include <tuple>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <tuple> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_apply
+#   error "__cpp_lib_apply should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should not be defined before c++14"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_apply
+#   error "__cpp_lib_apply should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should be defined in c++14"
+# endif
+# if __cpp_lib_tuple_element_t != 201402L
+#   error "__cpp_lib_tuple_element_t should have the value 201402L in c++14"
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++14"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++14"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_apply
+#   error "__cpp_lib_apply should be defined in c++17"
+# endif
+# if __cpp_lib_apply != 201603L
+#   error "__cpp_lib_apply should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should be defined in c++17"
+# endif
+# if __cpp_lib_make_from_tuple != 201606L
+#   error "__cpp_lib_make_from_tuple should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should be defined in c++17"
+# endif
+# if __cpp_lib_tuple_element_t != 201402L
+#   error "__cpp_lib_tuple_element_t should have the value 201402L in c++17"
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++17"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_apply
+#   error "__cpp_lib_apply should be defined in c++2a"
+# endif
+# if __cpp_lib_apply != 201603L
+#   error "__cpp_lib_apply should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_misc != 201811L
+#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should be defined in c++2a"
+# endif
+# if __cpp_lib_make_from_tuple != 201606L
+#   error "__cpp_lib_make_from_tuple should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should be defined in c++2a"
+# endif
+# if __cpp_lib_tuple_element_t != 201402L
+#   error "__cpp_lib_tuple_element_t should have the value 201402L in c++2a"
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++2a"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
index e53da7ef7..1a8229027 100644
--- a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,47 +7,391 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <type_traits> feature macros
-
-/*  Constant                                    Value
-    __cpp_lib_bool_constant                     201505L
-    __cpp_lib_has_unique_object_representations 201606L
-    __cpp_lib_integral_constant_callable        201304L
-    __cpp_lib_is_aggregate                      201703L
-    __cpp_lib_is_final                          201402L
-    __cpp_lib_is_invocable                      201703L
-    __cpp_lib_is_null_pointer                   201309L
-    __cpp_lib_is_swappable                      201603L
-    __cpp_lib_logical_traits                    201510L
-    __cpp_lib_result_of_sfinae                  201210L
-    __cpp_lib_transformation_trait_aliases      201304L
-    __cpp_lib_type_trait_variable_templates     201510L
-    __cpp_lib_void_t                            201411L
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <type_traits>
+
+// Test the feature test macros defined by <type_traits>
 
+/*  Constant                                       Value
+    __cpp_lib_bool_constant                        201505L [C++17]
+    __cpp_lib_has_unique_object_representations    201606L [C++17]
+    __cpp_lib_integral_constant_callable           201304L [C++14]
+    __cpp_lib_is_aggregate                         201703L [C++17]
+    __cpp_lib_is_constant_evaluated                201811L [C++2a]
+    __cpp_lib_is_final                             201402L [C++14]
+    __cpp_lib_is_invocable                         201703L [C++17]
+    __cpp_lib_is_null_pointer                      201309L [C++14]
+    __cpp_lib_is_swappable                         201603L [C++17]
+    __cpp_lib_logical_traits                       201510L [C++17]
+    __cpp_lib_result_of_sfinae                     201210L [C++14]
+    __cpp_lib_transformation_trait_aliases         201304L [C++14]
+    __cpp_lib_type_trait_variable_templates        201510L [C++17]
+    __cpp_lib_void_t                               201411L [C++17]
 */
 
 #include <type_traits>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <type_traits> are defined.
+#if TEST_STD_VER < 14
 
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_void_t)
-#  error "__cpp_lib_void_t is not defined"
-# elif __cpp_lib_void_t < 201411L
-#  error "__cpp_lib_void_t has an invalid value"
+# ifdef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should not be defined before c++17"
 # endif
-#endif
 
+# ifdef __cpp_lib_has_unique_object_representations
+#   error "__cpp_lib_has_unique_object_representations should not be defined before c++17"
+# endif
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_is_aggregate
+#   error "__cpp_lib_is_aggregate should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_constant_evaluated
+#   error "__cpp_lib_is_constant_evaluated should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_has_unique_object_representations
+#   error "__cpp_lib_has_unique_object_representations should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should be defined in c++14"
+# endif
+# if __cpp_lib_integral_constant_callable != 201304L
+#   error "__cpp_lib_integral_constant_callable should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_is_aggregate
+#   error "__cpp_lib_is_aggregate should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_constant_evaluated
+#   error "__cpp_lib_is_constant_evaluated should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should be defined in c++14"
+# endif
+# if __cpp_lib_is_final != 201402L
+#   error "__cpp_lib_is_final should have the value 201402L in c++14"
+# endif
+
+# ifdef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should be defined in c++14"
+# endif
+# if __cpp_lib_is_null_pointer != 201309L
+#   error "__cpp_lib_is_null_pointer should have the value 201309L in c++14"
+# endif
+
+# ifdef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++14"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++14"
+# endif
+
+# ifndef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should be defined in c++14"
+# endif
+# if __cpp_lib_transformation_trait_aliases != 201304L
+#   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should be defined in c++17"
+# endif
+# if __cpp_lib_bool_constant != 201505L
+#   error "__cpp_lib_bool_constant should have the value 201505L in c++17"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should be defined in c++17"
+#   endif
+#   if __cpp_lib_has_unique_object_representations != 201606L
+#     error "__cpp_lib_has_unique_object_representations should have the value 201606L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should be defined in c++17"
+# endif
+# if __cpp_lib_integral_constant_callable != 201304L
+#   error "__cpp_lib_integral_constant_callable should have the value 201304L in c++17"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001
+#   ifndef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should be defined in c++17"
+#   endif
+#   if __cpp_lib_is_aggregate != 201703L
+#     error "__cpp_lib_is_aggregate should have the value 201703L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001 is not defined!"
+#   endif
+# endif
+
+# ifdef __cpp_lib_is_constant_evaluated
+#   error "__cpp_lib_is_constant_evaluated should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should be defined in c++17"
+# endif
+# if __cpp_lib_is_final != 201402L
+#   error "__cpp_lib_is_final should have the value 201402L in c++17"
+# endif
+
+# ifndef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should be defined in c++17"
+# endif
+# if __cpp_lib_is_invocable != 201703L
+#   error "__cpp_lib_is_invocable should have the value 201703L in c++17"
+# endif
+
+# ifndef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should be defined in c++17"
+# endif
+# if __cpp_lib_is_null_pointer != 201309L
+#   error "__cpp_lib_is_null_pointer should have the value 201309L in c++17"
+# endif
+
+# ifndef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should be defined in c++17"
+# endif
+# if __cpp_lib_is_swappable != 201603L
+#   error "__cpp_lib_is_swappable should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should be defined in c++17"
+# endif
+# if __cpp_lib_logical_traits != 201510L
+#   error "__cpp_lib_logical_traits should have the value 201510L in c++17"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++17"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++17"
+# endif
+
+# ifndef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should be defined in c++17"
+# endif
+# if __cpp_lib_transformation_trait_aliases != 201304L
+#   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should be defined in c++17"
+# endif
+# if __cpp_lib_type_trait_variable_templates != 201510L
+#   error "__cpp_lib_type_trait_variable_templates should have the value 201510L in c++17"
+# endif
+
+# ifndef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should be defined in c++17"
+# endif
+# if __cpp_lib_void_t != 201411L
+#   error "__cpp_lib_void_t should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should be defined in c++2a"
+# endif
+# if __cpp_lib_bool_constant != 201505L
+#   error "__cpp_lib_bool_constant should have the value 201505L in c++2a"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should be defined in c++2a"
+#   endif
+#   if __cpp_lib_has_unique_object_representations != 201606L
+#     error "__cpp_lib_has_unique_object_representations should have the value 201606L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should be defined in c++2a"
+# endif
+# if __cpp_lib_integral_constant_callable != 201304L
+#   error "__cpp_lib_integral_constant_callable should have the value 201304L in c++2a"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001
+#   ifndef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should be defined in c++2a"
+#   endif
+#   if __cpp_lib_is_aggregate != 201703L
+#     error "__cpp_lib_is_aggregate should have the value 201703L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001 is not defined!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_is_constant_evaluated
+#     error "__cpp_lib_is_constant_evaluated should be defined in c++2a"
+#   endif
+#   if __cpp_lib_is_constant_evaluated != 201811L
+#     error "__cpp_lib_is_constant_evaluated should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_is_constant_evaluated
+#     error "__cpp_lib_is_constant_evaluated should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should be defined in c++2a"
+# endif
+# if __cpp_lib_is_final != 201402L
+#   error "__cpp_lib_is_final should have the value 201402L in c++2a"
+# endif
+
+# ifndef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should be defined in c++2a"
+# endif
+# if __cpp_lib_is_invocable != 201703L
+#   error "__cpp_lib_is_invocable should have the value 201703L in c++2a"
+# endif
+
+# ifndef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should be defined in c++2a"
+# endif
+# if __cpp_lib_is_null_pointer != 201309L
+#   error "__cpp_lib_is_null_pointer should have the value 201309L in c++2a"
+# endif
+
+# ifndef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should be defined in c++2a"
+# endif
+# if __cpp_lib_is_swappable != 201603L
+#   error "__cpp_lib_is_swappable should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should be defined in c++2a"
+# endif
+# if __cpp_lib_logical_traits != 201510L
+#   error "__cpp_lib_logical_traits should have the value 201510L in c++2a"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++2a"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++2a"
+# endif
+
+# ifndef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should be defined in c++2a"
+# endif
+# if __cpp_lib_transformation_trait_aliases != 201304L
+#   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should be defined in c++2a"
+# endif
+# if __cpp_lib_type_trait_variable_templates != 201510L
+#   error "__cpp_lib_type_trait_variable_templates should have the value 201510L in c++2a"
+# endif
+
+# ifndef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should be defined in c++2a"
+# endif
+# if __cpp_lib_void_t != 201411L
+#   error "__cpp_lib_void_t should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
index d23a91a30..75ce435dd 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,41 +7,165 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <unordered_map> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <unordered_map>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_node_extract                      201606L
-    __cpp_lib_nonmember_container_access        201411L
-    __cpp_lib_unordered_map_try_emplace         201411L
+// Test the feature test macros defined by <unordered_map>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_generic_unordered_lookup            201811L [C++2a]
+    __cpp_lib_node_extract                        201606L [C++17]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
+    __cpp_lib_unordered_map_try_emplace           201411L [C++17]
 */
 
 #include <unordered_map>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <unordered_map> are defined.
+#if TEST_STD_VER < 14
 
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
 # endif
-#endif
 
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++17"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should be defined in c++17"
+# endif
+# if __cpp_lib_unordered_map_try_emplace != 201411L
+#   error "__cpp_lib_unordered_map_try_emplace should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_generic_unordered_lookup
+#     error "__cpp_lib_generic_unordered_lookup should be defined in c++2a"
+#   endif
+#   if __cpp_lib_generic_unordered_lookup != 201811L
+#     error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_generic_unordered_lookup
+#     error "__cpp_lib_generic_unordered_lookup should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++2a"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should be defined in c++2a"
+# endif
+# if __cpp_lib_unordered_map_try_emplace != 201411L
+#   error "__cpp_lib_unordered_map_try_emplace should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
index c4dbed14b..c08a8fbd7 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,39 +7,142 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <unordered_set> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <unordered_set>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_node_extract                      201606L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <unordered_set>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_generic_unordered_lookup            201811L [C++2a]
+    __cpp_lib_node_extract                        201606L [C++17]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <unordered_set>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <unordered_set> are defined.
-
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++17"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_generic_unordered_lookup
+#     error "__cpp_lib_generic_unordered_lookup should be defined in c++2a"
+#   endif
+#   if __cpp_lib_generic_unordered_lookup != 201811L
+#     error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_generic_unordered_lookup
+#     error "__cpp_lib_generic_unordered_lookup should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++2a"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
index dff687f4b..e24e0a38b 100644
--- a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,29 +7,189 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <utility> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <utility>
 
-/*  Constant                                    Value
-    __cpp_lib_as_const                          201510L
-    __cpp_lib_exchange_function                 201304L
-    __cpp_lib_integer_sequence                  201304L
-    __cpp_lib_tuples_by_type                    201304L
+// Test the feature test macros defined by <utility>
 
+/*  Constant                       Value
+    __cpp_lib_as_const             201510L [C++17]
+    __cpp_lib_constexpr_misc       201811L [C++2a]
+    __cpp_lib_exchange_function    201304L [C++14]
+    __cpp_lib_integer_sequence     201304L [C++14]
+    __cpp_lib_to_chars             201611L [C++17]
+    __cpp_lib_tuples_by_type       201304L [C++14]
 */
 
 #include <utility>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <utility> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_to_chars
+#   error "__cpp_lib_to_chars should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should not be defined before c++14"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should be defined in c++14"
+# endif
+# if __cpp_lib_exchange_function != 201304L
+#   error "__cpp_lib_exchange_function should have the value 201304L in c++14"
+# endif
+
+# ifndef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should be defined in c++14"
+# endif
+# if __cpp_lib_integer_sequence != 201304L
+#   error "__cpp_lib_integer_sequence should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_to_chars
+#   error "__cpp_lib_to_chars should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++14"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++14"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should be defined in c++17"
+# endif
+# if __cpp_lib_as_const != 201510L
+#   error "__cpp_lib_as_const should have the value 201510L in c++17"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should be defined in c++17"
+# endif
+# if __cpp_lib_exchange_function != 201304L
+#   error "__cpp_lib_exchange_function should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should be defined in c++17"
+# endif
+# if __cpp_lib_integer_sequence != 201304L
+#   error "__cpp_lib_integer_sequence should have the value 201304L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should be defined in c++17"
+#   endif
+#   if __cpp_lib_to_chars != 201611L
+#     error "__cpp_lib_to_chars should have the value 201611L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++17"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should be defined in c++2a"
+# endif
+# if __cpp_lib_as_const != 201510L
+#   error "__cpp_lib_as_const should have the value 201510L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_misc != 201811L
+#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should be defined in c++2a"
+# endif
+# if __cpp_lib_exchange_function != 201304L
+#   error "__cpp_lib_exchange_function should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should be defined in c++2a"
+# endif
+# if __cpp_lib_integer_sequence != 201304L
+#   error "__cpp_lib_integer_sequence should have the value 201304L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should be defined in c++2a"
+#   endif
+#   if __cpp_lib_to_chars != 201611L
+#     error "__cpp_lib_to_chars should have the value 201611L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++2a"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
index 5532e0446..b822eb74f 100644
--- a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,26 +7,50 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <variant> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <variant>
 
-/*  Constant                                    Value
-    __cpp_lib_variant                           201606L
+// Test the feature test macros defined by <variant>
 
+/*  Constant             Value
+    __cpp_lib_variant    201606L [C++17]
 */
 
 #include <variant>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <variant> are defined.
+#if TEST_STD_VER < 14
 
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_variant
+#   error "__cpp_lib_variant should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_variant
+#   error "__cpp_lib_variant should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_variant
+#   error "__cpp_lib_variant should be defined in c++17"
+# endif
+# if __cpp_lib_variant != 201606L
+#   error "__cpp_lib_variant should have the value 201606L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_variant
+#   error "__cpp_lib_variant should be defined in c++2a"
+# endif
+# if __cpp_lib_variant != 201606L
+#   error "__cpp_lib_variant should have the value 201606L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
index e7cb1942c..6ba328d5c 100644
--- a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,39 +7,116 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <vector> feature macros
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <vector>
 
-/*  Constant                                    Value
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_erase_if                          201811L
-    __cpp_lib_incomplete_container_elements     201505L
-    __cpp_lib_nonmember_container_access        201411L
+// Test the feature test macros defined by <vector>
 
+/*  Constant                                      Value
+    __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
+    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_incomplete_container_elements       201505L [C++17]
+    __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <vector>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <vector> are defined.
-
-#if TEST_STD_VER > 17
-# if !defined(__cpp_lib_erase_if)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
-# else
-#  if __cpp_lib_erase_if < 201811L
-#   error "__cpp_lib_erase_if has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++17"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++17"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
index 29fe4b298..6f7d649f5 100644
--- a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -1,4 +1,3 @@
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -8,142 +7,2130 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// <version> feature macros
-
-/*  Constant                                    Value
-    __cpp_lib_addressof_constexpr               201603L
-    __cpp_lib_allocator_traits_is_always_equal  201411L
-    __cpp_lib_any                               201606L
-    __cpp_lib_apply                             201603L
-    __cpp_lib_array_constexpr                   201603L
-    __cpp_lib_as_const                          201510L
-    __cpp_lib_atomic_is_always_lock_free        201603L
-    __cpp_lib_atomic_ref                        201806L
-    __cpp_lib_bit_cast                          201806L
-    __cpp_lib_bool_constant                     201505L
-    __cpp_lib_boyer_moore_searcher              201603L
-    __cpp_lib_byte                              201603L
-    __cpp_lib_chrono                            201611L
-    __cpp_lib_chrono_udls                       201304L
-    __cpp_lib_clamp                             201603L
-    __cpp_lib_complex_udls                      201309L
-    __cpp_lib_concepts                          201806L
-    __cpp_lib_constexpr_swap_algorithms         201806L
-    __cpp_lib_destroying_delete                 201806L
-    __cpp_lib_enable_shared_from_this           201603L
-    __cpp_lib_exchange_function                 201304L
-    __cpp_lib_execution                         201603L
-    __cpp_lib_filesystem                        201703L
-    __cpp_lib_gcd_lcm                           201606L
-    __cpp_lib_generic_associative_lookup        201304L
-    __cpp_lib_hardware_interference_size        201703L
-    __cpp_lib_has_unique_object_representations 201606L
-    __cpp_lib_hypot                             201603L
-    __cpp_lib_incomplete_container_elements     201505L
-    __cpp_lib_integer_sequence                  201304L
-    __cpp_lib_integral_constant_callable        201304L
-    __cpp_lib_invoke                            201411L
-    __cpp_lib_is_aggregate                      201703L
-    __cpp_lib_is_final                          201402L
-    __cpp_lib_is_invocable                      201703L
-    __cpp_lib_is_null_pointer                   201309L
-    __cpp_lib_is_swappable                      201603L
-    __cpp_lib_launder                           201606L
-    __cpp_lib_list_remove_return_type           201806L
-    __cpp_lib_logical_traits                    201510L
-    __cpp_lib_make_from_tuple                   201606L
-    __cpp_lib_make_reverse_iterator             201402L
-    __cpp_lib_make_unique                       201304L
-    __cpp_lib_map_try_emplace                   201411L
-    __cpp_lib_math_special_functions            201603L
-    __cpp_lib_memory_resource                   201603L
-    __cpp_lib_node_extract                      201606L
-    __cpp_lib_nonmember_container_access        201411L
-    __cpp_lib_not_fn                            201603L
-    __cpp_lib_null_iterators                    201304L
-    __cpp_lib_optional                          201606L
-    __cpp_lib_parallel_algorithm                201603L
-    __cpp_lib_quoted_string_io                  201304L
-    __cpp_lib_raw_memory_algorithms             201606L
-    __cpp_lib_result_of_sfinae                  201210L
-    __cpp_lib_robust_nonmodifying_seq_ops       201304L
-    __cpp_lib_sample                            201603L
-    __cpp_lib_scoped_lock                       201703L
-    __cpp_lib_shared_mutex                      201505L
-    __cpp_lib_shared_ptr_arrays                 201611L
-    __cpp_lib_shared_ptr_weak_type              201606L
-    __cpp_lib_shared_timed_mutex                201402L
-    __cpp_lib_string_udls                       201304L
-    __cpp_lib_string_view                       201606L
-    __cpp_lib_to_chars                          201611L
-    __cpp_lib_three_way_comparison              201711L
-    __cpp_lib_transformation_trait_aliases      201304L
-    __cpp_lib_transparent_operators             201510L
-    __cpp_lib_tuple_element_t                   201402L
-    __cpp_lib_tuples_by_type                    201304L
-    __cpp_lib_type_trait_variable_templates     201510L
-    __cpp_lib_uncaught_exceptions               201411L
-    __cpp_lib_unordered_map_try_emplace         201411L
-    __cpp_lib_variant                           201606L
-    __cpp_lib_void_t                            201411L
+// WARNING: This test was generated by generate_feature_test_macros_tests.py and
+// should not be edited manually.
+
+// <version>
 
+// Test the feature test macros defined by <version>
+
+/*  Constant                                       Value
+    __cpp_lib_addressof_constexpr                  201603L [C++17]
+    __cpp_lib_allocator_traits_is_always_equal     201411L [C++17]
+    __cpp_lib_any                                  201606L [C++17]
+    __cpp_lib_apply                                201603L [C++17]
+    __cpp_lib_array_constexpr                      201603L [C++17]
+    __cpp_lib_as_const                             201510L [C++17]
+    __cpp_lib_atomic_is_always_lock_free           201603L [C++17]
+    __cpp_lib_atomic_ref                           201806L [C++2a]
+    __cpp_lib_bind_front                           201811L [C++2a]
+    __cpp_lib_bit_cast                             201806L [C++2a]
+    __cpp_lib_bool_constant                        201505L [C++17]
+    __cpp_lib_boyer_moore_searcher                 201603L [C++17]
+    __cpp_lib_byte                                 201603L [C++17]
+    __cpp_lib_char8_t                              201811L [C++2a]
+    __cpp_lib_chrono                               201611L [C++17]
+    __cpp_lib_chrono_udls                          201304L [C++14]
+    __cpp_lib_clamp                                201603L [C++17]
+    __cpp_lib_complex_udls                         201309L [C++14]
+    __cpp_lib_concepts                             201806L [C++2a]
+    __cpp_lib_constexpr_misc                       201811L [C++2a]
+    __cpp_lib_constexpr_swap_algorithms            201806L [C++2a]
+    __cpp_lib_destroying_delete                    201806L [C++2a]
+    __cpp_lib_enable_shared_from_this              201603L [C++17]
+    __cpp_lib_erase_if                             201811L [C++2a]
+    __cpp_lib_exchange_function                    201304L [C++14]
+    __cpp_lib_execution                            201603L [C++17]
+    __cpp_lib_filesystem                           201703L [C++17]
+    __cpp_lib_gcd_lcm                              201606L [C++17]
+    __cpp_lib_generic_associative_lookup           201304L [C++14]
+    __cpp_lib_generic_unordered_lookup             201811L [C++2a]
+    __cpp_lib_hardware_interference_size           201703L [C++17]
+    __cpp_lib_has_unique_object_representations    201606L [C++17]
+    __cpp_lib_hypot                                201603L [C++17]
+    __cpp_lib_incomplete_container_elements        201505L [C++17]
+    __cpp_lib_integer_sequence                     201304L [C++14]
+    __cpp_lib_integral_constant_callable           201304L [C++14]
+    __cpp_lib_invoke                               201411L [C++17]
+    __cpp_lib_is_aggregate                         201703L [C++17]
+    __cpp_lib_is_constant_evaluated                201811L [C++2a]
+    __cpp_lib_is_final                             201402L [C++14]
+    __cpp_lib_is_invocable                         201703L [C++17]
+    __cpp_lib_is_null_pointer                      201309L [C++14]
+    __cpp_lib_is_swappable                         201603L [C++17]
+    __cpp_lib_launder                              201606L [C++17]
+    __cpp_lib_list_remove_return_type              201806L [C++2a]
+    __cpp_lib_logical_traits                       201510L [C++17]
+    __cpp_lib_make_from_tuple                      201606L [C++17]
+    __cpp_lib_make_reverse_iterator                201402L [C++14]
+    __cpp_lib_make_unique                          201304L [C++14]
+    __cpp_lib_map_try_emplace                      201411L [C++17]
+    __cpp_lib_math_special_functions               201603L [C++17]
+    __cpp_lib_memory_resource                      201603L [C++17]
+    __cpp_lib_node_extract                         201606L [C++17]
+    __cpp_lib_nonmember_container_access           201411L [C++17]
+    __cpp_lib_not_fn                               201603L [C++17]
+    __cpp_lib_null_iterators                       201304L [C++14]
+    __cpp_lib_optional                             201606L [C++17]
+    __cpp_lib_parallel_algorithm                   201603L [C++17]
+    __cpp_lib_quoted_string_io                     201304L [C++14]
+    __cpp_lib_ranges                               201811L [C++2a]
+    __cpp_lib_raw_memory_algorithms                201606L [C++17]
+    __cpp_lib_result_of_sfinae                     201210L [C++14]
+    __cpp_lib_robust_nonmodifying_seq_ops          201304L [C++14]
+    __cpp_lib_sample                               201603L [C++17]
+    __cpp_lib_scoped_lock                          201703L [C++17]
+    __cpp_lib_shared_mutex                         201505L [C++17]
+    __cpp_lib_shared_ptr_arrays                    201611L [C++17]
+    __cpp_lib_shared_ptr_weak_type                 201606L [C++17]
+    __cpp_lib_shared_timed_mutex                   201402L [C++14]
+    __cpp_lib_string_udls                          201304L [C++14]
+    __cpp_lib_string_view                          201606L [C++17]
+    __cpp_lib_three_way_comparison                 201711L [C++2a]
+    __cpp_lib_to_chars                             201611L [C++17]
+    __cpp_lib_transformation_trait_aliases         201304L [C++14]
+    __cpp_lib_transparent_operators                201210L [C++14]
+                                                   201510L [C++17]
+    __cpp_lib_tuple_element_t                      201402L [C++14]
+    __cpp_lib_tuples_by_type                       201304L [C++14]
+    __cpp_lib_type_trait_variable_templates        201510L [C++17]
+    __cpp_lib_uncaught_exceptions                  201411L [C++17]
+    __cpp_lib_unordered_map_try_emplace            201411L [C++17]
+    __cpp_lib_variant                              201606L [C++17]
+    __cpp_lib_void_t                               201411L [C++17]
 */
 
 #include <version>
-#include <cassert>
 #include "test_macros.h"
 
-int main()
-{
-//  ensure that the macros that are supposed to be defined in <version> are defined.
+#if TEST_STD_VER < 14
 
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_atomic_is_always_lock_free)
-#  error "__cpp_lib_atomic_is_always_lock_free is not defined"
-# elif __cpp_lib_atomic_is_always_lock_free < 201603L
-#  error "__cpp_lib_atomic_is_always_lock_free has an invalid value"
+# ifdef __cpp_lib_addressof_constexpr
+#   error "__cpp_lib_addressof_constexpr should not be defined before c++17"
 # endif
-#endif
 
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_filesystem)
-#  error "__cpp_lib_filesystem is not defined"
-# elif __cpp_lib_filesystem < 201703L
-#  error "__cpp_lib_filesystem has an invalid value"
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
 # endif
-#endif
 
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_invoke)
-#  error "__cpp_lib_invoke is not defined"
-# elif __cpp_lib_invoke < 201411L
-#  error "__cpp_lib_invoke has an invalid value"
+# ifdef __cpp_lib_any
+#   error "__cpp_lib_any should not be defined before c++17"
 # endif
-#endif
 
-#if TEST_STD_VER > 14
-# if !defined(__cpp_lib_void_t)
-#  error "__cpp_lib_void_t is not defined"
-# elif __cpp_lib_void_t < 201411L
-#  error "__cpp_lib_void_t has an invalid value"
+# ifdef __cpp_lib_apply
+#   error "__cpp_lib_apply should not be defined before c++17"
 # endif
-#endif
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-# if !defined(__cpp_lib_char8_t)  
-  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_char8_t is not defined");
-# else
-#  if __cpp_lib_char8_t < 201811L
-#   error "__cpp_lib_char8_t has an invalid value"
-#  endif
-# endif
-#endif
-
-/*
-#if !defined(__cpp_lib_fooby)
-# error "__cpp_lib_fooby is not defined"
-#elif __cpp_lib_fooby < 201606L
-# error "__cpp_lib_fooby has an invalid value"
-#endif
-*/
-}
+# ifdef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_ref
+#   error "__cpp_lib_atomic_ref should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_boyer_moore_searcher
+#   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_byte
+#   error "__cpp_lib_byte should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_concepts
+#   error "__cpp_lib_concepts should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_swap_algorithms
+#   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_destroying_delete
+#   error "__cpp_lib_destroying_delete should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_execution
+#   error "__cpp_lib_execution should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_has_unique_object_representations
+#   error "__cpp_lib_has_unique_object_representations should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_aggregate
+#   error "__cpp_lib_is_aggregate should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_constant_evaluated
+#   error "__cpp_lib_is_constant_evaluated should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_launder
+#   error "__cpp_lib_launder should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_math_special_functions
+#   error "__cpp_lib_math_special_functions should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_memory_resource
+#   error "__cpp_lib_memory_resource should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_optional
+#   error "__cpp_lib_optional should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_parallel_algorithm
+#   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_sample
+#   error "__cpp_lib_sample should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_arrays
+#   error "__cpp_lib_shared_ptr_arrays should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_three_way_comparison
+#   error "__cpp_lib_three_way_comparison should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_to_chars
+#   error "__cpp_lib_to_chars should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should not be defined before c++14"
+# endif
+
+# ifdef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_variant
+#   error "__cpp_lib_variant should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_addressof_constexpr
+#   error "__cpp_lib_addressof_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_any
+#   error "__cpp_lib_any should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_apply
+#   error "__cpp_lib_apply should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_ref
+#   error "__cpp_lib_atomic_ref should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_boyer_moore_searcher
+#   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_byte
+#   error "__cpp_lib_byte should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should be defined in c++14"
+# endif
+# if __cpp_lib_chrono_udls != 201304L
+#   error "__cpp_lib_chrono_udls should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should be defined in c++14"
+# endif
+# if __cpp_lib_complex_udls != 201309L
+#   error "__cpp_lib_complex_udls should have the value 201309L in c++14"
+# endif
+
+# ifdef __cpp_lib_concepts
+#   error "__cpp_lib_concepts should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_swap_algorithms
+#   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_destroying_delete
+#   error "__cpp_lib_destroying_delete should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should be defined in c++14"
+# endif
+# if __cpp_lib_exchange_function != 201304L
+#   error "__cpp_lib_exchange_function should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_execution
+#   error "__cpp_lib_execution should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++14"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_has_unique_object_representations
+#   error "__cpp_lib_has_unique_object_representations should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should be defined in c++14"
+# endif
+# if __cpp_lib_integer_sequence != 201304L
+#   error "__cpp_lib_integer_sequence should have the value 201304L in c++14"
+# endif
+
+# ifndef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should be defined in c++14"
+# endif
+# if __cpp_lib_integral_constant_callable != 201304L
+#   error "__cpp_lib_integral_constant_callable should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_aggregate
+#   error "__cpp_lib_is_aggregate should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_is_constant_evaluated
+#   error "__cpp_lib_is_constant_evaluated should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should be defined in c++14"
+# endif
+# if __cpp_lib_is_final != 201402L
+#   error "__cpp_lib_is_final should have the value 201402L in c++14"
+# endif
+
+# ifdef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should be defined in c++14"
+# endif
+# if __cpp_lib_is_null_pointer != 201309L
+#   error "__cpp_lib_is_null_pointer should have the value 201309L in c++14"
+# endif
+
+# ifdef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_launder
+#   error "__cpp_lib_launder should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should be defined in c++14"
+# endif
+# if __cpp_lib_make_reverse_iterator != 201402L
+#   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++14"
+# endif
+
+# ifndef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should be defined in c++14"
+# endif
+# if __cpp_lib_make_unique != 201304L
+#   error "__cpp_lib_make_unique should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_math_special_functions
+#   error "__cpp_lib_math_special_functions should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_memory_resource
+#   error "__cpp_lib_memory_resource should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should be defined in c++14"
+# endif
+# if __cpp_lib_null_iterators != 201304L
+#   error "__cpp_lib_null_iterators should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_optional
+#   error "__cpp_lib_optional should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_parallel_algorithm
+#   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should be defined in c++14"
+# endif
+# if __cpp_lib_quoted_string_io != 201304L
+#   error "__cpp_lib_quoted_string_io should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++14"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++14"
+# endif
+
+# ifndef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++14"
+# endif
+# if __cpp_lib_robust_nonmodifying_seq_ops != 201304L
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_sample
+#   error "__cpp_lib_sample should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_arrays
+#   error "__cpp_lib_shared_ptr_arrays should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should be defined in c++14"
+# endif
+# if __cpp_lib_shared_timed_mutex != 201402L
+#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++14"
+# endif
+
+# ifndef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should be defined in c++14"
+# endif
+# if __cpp_lib_string_udls != 201304L
+#   error "__cpp_lib_string_udls should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_three_way_comparison
+#   error "__cpp_lib_three_way_comparison should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_to_chars
+#   error "__cpp_lib_to_chars should not be defined before c++17"
+# endif
+
+# ifndef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should be defined in c++14"
+# endif
+# if __cpp_lib_transformation_trait_aliases != 201304L
+#   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++14"
+# endif
+
+# ifndef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should be defined in c++14"
+# endif
+# if __cpp_lib_transparent_operators != 201210L
+#   error "__cpp_lib_transparent_operators should have the value 201210L in c++14"
+# endif
+
+# ifndef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should be defined in c++14"
+# endif
+# if __cpp_lib_tuple_element_t != 201402L
+#   error "__cpp_lib_tuple_element_t should have the value 201402L in c++14"
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++14"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++14"
+# endif
+
+# ifdef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_variant
+#   error "__cpp_lib_variant should not be defined before c++17"
+# endif
+
+# ifdef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should not be defined before c++17"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# if TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should be defined in c++17"
+#   endif
+#   if __cpp_lib_addressof_constexpr != 201603L
+#     error "__cpp_lib_addressof_constexpr should have the value 201603L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should not be defined when TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++17"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_any
+#   error "__cpp_lib_any should be defined in c++17"
+# endif
+# if __cpp_lib_any != 201606L
+#   error "__cpp_lib_any should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_apply
+#   error "__cpp_lib_apply should be defined in c++17"
+# endif
+# if __cpp_lib_apply != 201603L
+#   error "__cpp_lib_apply should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should be defined in c++17"
+# endif
+# if __cpp_lib_array_constexpr != 201603L
+#   error "__cpp_lib_array_constexpr should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should be defined in c++17"
+# endif
+# if __cpp_lib_as_const != 201510L
+#   error "__cpp_lib_as_const should have the value 201510L in c++17"
+# endif
+
+# ifndef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
+# endif
+# if __cpp_lib_atomic_is_always_lock_free != 201603L
+#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_atomic_ref
+#   error "__cpp_lib_atomic_ref should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should be defined in c++17"
+# endif
+# if __cpp_lib_bool_constant != 201505L
+#   error "__cpp_lib_bool_constant should have the value 201505L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should be defined in c++17"
+#   endif
+#   if __cpp_lib_boyer_moore_searcher != 201603L
+#     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_byte
+#   error "__cpp_lib_byte should be defined in c++17"
+# endif
+# if __cpp_lib_byte != 201603L
+#   error "__cpp_lib_byte should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_char8_t
+#   error "__cpp_lib_char8_t should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should be defined in c++17"
+# endif
+# if __cpp_lib_chrono != 201611L
+#   error "__cpp_lib_chrono should have the value 201611L in c++17"
+# endif
+
+# ifndef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should be defined in c++17"
+# endif
+# if __cpp_lib_chrono_udls != 201304L
+#   error "__cpp_lib_chrono_udls should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should be defined in c++17"
+# endif
+# if __cpp_lib_clamp != 201603L
+#   error "__cpp_lib_clamp should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should be defined in c++17"
+# endif
+# if __cpp_lib_complex_udls != 201309L
+#   error "__cpp_lib_complex_udls should have the value 201309L in c++17"
+# endif
+
+# ifdef __cpp_lib_concepts
+#   error "__cpp_lib_concepts should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_misc
+#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_constexpr_swap_algorithms
+#   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
+# endif
+
+# ifdef __cpp_lib_destroying_delete
+#   error "__cpp_lib_destroying_delete should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should be defined in c++17"
+# endif
+# if __cpp_lib_enable_shared_from_this != 201603L
+#   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++17"
+# endif
+
+# ifdef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should be defined in c++17"
+# endif
+# if __cpp_lib_exchange_function != 201304L
+#   error "__cpp_lib_exchange_function should have the value 201304L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_execution
+#     error "__cpp_lib_execution should be defined in c++17"
+#   endif
+#   if __cpp_lib_execution != 201603L
+#     error "__cpp_lib_execution should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_execution
+#     error "__cpp_lib_execution should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should be defined in c++17"
+# endif
+# if __cpp_lib_filesystem != 201703L
+#   error "__cpp_lib_filesystem should have the value 201703L in c++17"
+# endif
+
+# ifndef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should be defined in c++17"
+# endif
+# if __cpp_lib_gcd_lcm != 201606L
+#   error "__cpp_lib_gcd_lcm should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++17"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++17"
+# endif
+
+# ifdef __cpp_lib_generic_unordered_lookup
+#   error "__cpp_lib_generic_unordered_lookup should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++17"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++17"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should be defined in c++17"
+#   endif
+#   if __cpp_lib_has_unique_object_representations != 201606L
+#     error "__cpp_lib_has_unique_object_representations should have the value 201606L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should be defined in c++17"
+# endif
+# if __cpp_lib_hypot != 201603L
+#   error "__cpp_lib_hypot should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++17"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++17"
+# endif
+
+# ifndef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should be defined in c++17"
+# endif
+# if __cpp_lib_integer_sequence != 201304L
+#   error "__cpp_lib_integer_sequence should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should be defined in c++17"
+# endif
+# if __cpp_lib_integral_constant_callable != 201304L
+#   error "__cpp_lib_integral_constant_callable should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should be defined in c++17"
+# endif
+# if __cpp_lib_invoke != 201411L
+#   error "__cpp_lib_invoke should have the value 201411L in c++17"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001
+#   ifndef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should be defined in c++17"
+#   endif
+#   if __cpp_lib_is_aggregate != 201703L
+#     error "__cpp_lib_is_aggregate should have the value 201703L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001 is not defined!"
+#   endif
+# endif
+
+# ifdef __cpp_lib_is_constant_evaluated
+#   error "__cpp_lib_is_constant_evaluated should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should be defined in c++17"
+# endif
+# if __cpp_lib_is_final != 201402L
+#   error "__cpp_lib_is_final should have the value 201402L in c++17"
+# endif
+
+# ifndef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should be defined in c++17"
+# endif
+# if __cpp_lib_is_invocable != 201703L
+#   error "__cpp_lib_is_invocable should have the value 201703L in c++17"
+# endif
+
+# ifndef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should be defined in c++17"
+# endif
+# if __cpp_lib_is_null_pointer != 201309L
+#   error "__cpp_lib_is_null_pointer should have the value 201309L in c++17"
+# endif
+
+# ifndef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should be defined in c++17"
+# endif
+# if __cpp_lib_is_swappable != 201603L
+#   error "__cpp_lib_is_swappable should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_launder
+#   error "__cpp_lib_launder should be defined in c++17"
+# endif
+# if __cpp_lib_launder != 201606L
+#   error "__cpp_lib_launder should have the value 201606L in c++17"
+# endif
+
+# ifdef __cpp_lib_list_remove_return_type
+#   error "__cpp_lib_list_remove_return_type should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should be defined in c++17"
+# endif
+# if __cpp_lib_logical_traits != 201510L
+#   error "__cpp_lib_logical_traits should have the value 201510L in c++17"
+# endif
+
+# ifndef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should be defined in c++17"
+# endif
+# if __cpp_lib_make_from_tuple != 201606L
+#   error "__cpp_lib_make_from_tuple should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should be defined in c++17"
+# endif
+# if __cpp_lib_make_reverse_iterator != 201402L
+#   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++17"
+# endif
+
+# ifndef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should be defined in c++17"
+# endif
+# if __cpp_lib_make_unique != 201304L
+#   error "__cpp_lib_make_unique should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should be defined in c++17"
+# endif
+# if __cpp_lib_map_try_emplace != 201411L
+#   error "__cpp_lib_map_try_emplace should have the value 201411L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should be defined in c++17"
+#   endif
+#   if __cpp_lib_math_special_functions != 201603L
+#     error "__cpp_lib_math_special_functions should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++17"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++17"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++17"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should be defined in c++17"
+# endif
+# if __cpp_lib_not_fn != 201603L
+#   error "__cpp_lib_not_fn should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should be defined in c++17"
+# endif
+# if __cpp_lib_null_iterators != 201304L
+#   error "__cpp_lib_null_iterators should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_optional
+#   error "__cpp_lib_optional should be defined in c++17"
+# endif
+# if __cpp_lib_optional != 201606L
+#   error "__cpp_lib_optional should have the value 201606L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should be defined in c++17"
+#   endif
+#   if __cpp_lib_parallel_algorithm != 201603L
+#     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should be defined in c++17"
+# endif
+# if __cpp_lib_quoted_string_io != 201304L
+#   error "__cpp_lib_quoted_string_io should have the value 201304L in c++17"
+# endif
+
+# ifdef __cpp_lib_ranges
+#   error "__cpp_lib_ranges should not be defined before c++2a"
+# endif
+
+# ifndef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should be defined in c++17"
+# endif
+# if __cpp_lib_raw_memory_algorithms != 201606L
+#   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++17"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++17"
+# endif
+
+# ifndef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++17"
+# endif
+# if __cpp_lib_robust_nonmodifying_seq_ops != 201304L
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_sample
+#   error "__cpp_lib_sample should be defined in c++17"
+# endif
+# if __cpp_lib_sample != 201603L
+#   error "__cpp_lib_sample should have the value 201603L in c++17"
+# endif
+
+# ifndef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should be defined in c++17"
+# endif
+# if __cpp_lib_scoped_lock != 201703L
+#   error "__cpp_lib_scoped_lock should have the value 201703L in c++17"
+# endif
+
+# ifndef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should be defined in c++17"
+# endif
+# if __cpp_lib_shared_mutex != 201505L
+#   error "__cpp_lib_shared_mutex should have the value 201505L in c++17"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should be defined in c++17"
+#   endif
+#   if __cpp_lib_shared_ptr_arrays != 201611L
+#     error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should be defined in c++17"
+# endif
+# if __cpp_lib_shared_ptr_weak_type != 201606L
+#   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should be defined in c++17"
+# endif
+# if __cpp_lib_shared_timed_mutex != 201402L
+#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++17"
+# endif
+
+# ifndef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should be defined in c++17"
+# endif
+# if __cpp_lib_string_udls != 201304L
+#   error "__cpp_lib_string_udls should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should be defined in c++17"
+# endif
+# if __cpp_lib_string_view != 201606L
+#   error "__cpp_lib_string_view should have the value 201606L in c++17"
+# endif
+
+# ifdef __cpp_lib_three_way_comparison
+#   error "__cpp_lib_three_way_comparison should not be defined before c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should be defined in c++17"
+#   endif
+#   if __cpp_lib_to_chars != 201611L
+#     error "__cpp_lib_to_chars should have the value 201611L in c++17"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should be defined in c++17"
+# endif
+# if __cpp_lib_transformation_trait_aliases != 201304L
+#   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should be defined in c++17"
+# endif
+# if __cpp_lib_transparent_operators != 201510L
+#   error "__cpp_lib_transparent_operators should have the value 201510L in c++17"
+# endif
+
+# ifndef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should be defined in c++17"
+# endif
+# if __cpp_lib_tuple_element_t != 201402L
+#   error "__cpp_lib_tuple_element_t should have the value 201402L in c++17"
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++17"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++17"
+# endif
+
+# ifndef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should be defined in c++17"
+# endif
+# if __cpp_lib_type_trait_variable_templates != 201510L
+#   error "__cpp_lib_type_trait_variable_templates should have the value 201510L in c++17"
+# endif
+
+# ifndef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should be defined in c++17"
+# endif
+# if __cpp_lib_uncaught_exceptions != 201411L
+#   error "__cpp_lib_uncaught_exceptions should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should be defined in c++17"
+# endif
+# if __cpp_lib_unordered_map_try_emplace != 201411L
+#   error "__cpp_lib_unordered_map_try_emplace should have the value 201411L in c++17"
+# endif
+
+# ifndef __cpp_lib_variant
+#   error "__cpp_lib_variant should be defined in c++17"
+# endif
+# if __cpp_lib_variant != 201606L
+#   error "__cpp_lib_variant should have the value 201606L in c++17"
+# endif
+
+# ifndef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should be defined in c++17"
+# endif
+# if __cpp_lib_void_t != 201411L
+#   error "__cpp_lib_void_t should have the value 201411L in c++17"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# if TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should be defined in c++2a"
+#   endif
+#   if __cpp_lib_addressof_constexpr != 201603L
+#     error "__cpp_lib_addressof_constexpr should have the value 201603L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_addressof_constexpr
+#     error "__cpp_lib_addressof_constexpr should not be defined when TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_allocator_traits_is_always_equal
+#   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2a"
+# endif
+# if __cpp_lib_allocator_traits_is_always_equal != 201411L
+#   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_any
+#   error "__cpp_lib_any should be defined in c++2a"
+# endif
+# if __cpp_lib_any != 201606L
+#   error "__cpp_lib_any should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_apply
+#   error "__cpp_lib_apply should be defined in c++2a"
+# endif
+# if __cpp_lib_apply != 201603L
+#   error "__cpp_lib_apply should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_array_constexpr
+#   error "__cpp_lib_array_constexpr should be defined in c++2a"
+# endif
+# if __cpp_lib_array_constexpr != 201603L
+#   error "__cpp_lib_array_constexpr should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_as_const
+#   error "__cpp_lib_as_const should be defined in c++2a"
+# endif
+# if __cpp_lib_as_const != 201510L
+#   error "__cpp_lib_as_const should have the value 201510L in c++2a"
+# endif
+
+# ifndef __cpp_lib_atomic_is_always_lock_free
+#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
+# endif
+# if __cpp_lib_atomic_is_always_lock_free != 201603L
+#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_atomic_ref
+#     error "__cpp_lib_atomic_ref should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_ref != 201806L
+#     error "__cpp_lib_atomic_ref should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_atomic_ref
+#     error "__cpp_lib_atomic_ref should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_bind_front
+#     error "__cpp_lib_bind_front should be defined in c++2a"
+#   endif
+#   if __cpp_lib_bind_front != 201811L
+#     error "__cpp_lib_bind_front should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_bind_front
+#     error "__cpp_lib_bind_front should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_bit_cast
+#     error "__cpp_lib_bit_cast should be defined in c++2a"
+#   endif
+#   if __cpp_lib_bit_cast != 201806L
+#     error "__cpp_lib_bit_cast should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_bit_cast
+#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_bool_constant
+#   error "__cpp_lib_bool_constant should be defined in c++2a"
+# endif
+# if __cpp_lib_bool_constant != 201505L
+#   error "__cpp_lib_bool_constant should have the value 201505L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should be defined in c++2a"
+#   endif
+#   if __cpp_lib_boyer_moore_searcher != 201603L
+#     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_boyer_moore_searcher
+#     error "__cpp_lib_boyer_moore_searcher should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_byte
+#   error "__cpp_lib_byte should be defined in c++2a"
+# endif
+# if __cpp_lib_byte != 201603L
+#   error "__cpp_lib_byte should have the value 201603L in c++2a"
+# endif
+
+# if defined(__cpp_char8_t)
+#   ifndef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should be defined in c++2a"
+#   endif
+#   if __cpp_lib_char8_t != 201811L
+#     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_char8_t
+#     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_chrono
+#   error "__cpp_lib_chrono should be defined in c++2a"
+# endif
+# if __cpp_lib_chrono != 201611L
+#   error "__cpp_lib_chrono should have the value 201611L in c++2a"
+# endif
+
+# ifndef __cpp_lib_chrono_udls
+#   error "__cpp_lib_chrono_udls should be defined in c++2a"
+# endif
+# if __cpp_lib_chrono_udls != 201304L
+#   error "__cpp_lib_chrono_udls should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_clamp
+#   error "__cpp_lib_clamp should be defined in c++2a"
+# endif
+# if __cpp_lib_clamp != 201603L
+#   error "__cpp_lib_clamp should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_complex_udls
+#   error "__cpp_lib_complex_udls should be defined in c++2a"
+# endif
+# if __cpp_lib_complex_udls != 201309L
+#   error "__cpp_lib_complex_udls should have the value 201309L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_concepts
+#     error "__cpp_lib_concepts should be defined in c++2a"
+#   endif
+#   if __cpp_lib_concepts != 201806L
+#     error "__cpp_lib_concepts should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_concepts
+#     error "__cpp_lib_concepts should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_misc != 201811L
+#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_misc
+#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_constexpr_swap_algorithms
+#     error "__cpp_lib_constexpr_swap_algorithms should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_swap_algorithms != 201806L
+#     error "__cpp_lib_constexpr_swap_algorithms should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_constexpr_swap_algorithms
+#     error "__cpp_lib_constexpr_swap_algorithms should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_destroying_delete
+#     error "__cpp_lib_destroying_delete should be defined in c++2a"
+#   endif
+#   if __cpp_lib_destroying_delete != 201806L
+#     error "__cpp_lib_destroying_delete should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_destroying_delete
+#     error "__cpp_lib_destroying_delete should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_enable_shared_from_this
+#   error "__cpp_lib_enable_shared_from_this should be defined in c++2a"
+# endif
+# if __cpp_lib_enable_shared_from_this != 201603L
+#   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_erase_if
+#   error "__cpp_lib_erase_if should be defined in c++2a"
+# endif
+# if __cpp_lib_erase_if != 201811L
+#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# endif
+
+# ifndef __cpp_lib_exchange_function
+#   error "__cpp_lib_exchange_function should be defined in c++2a"
+# endif
+# if __cpp_lib_exchange_function != 201304L
+#   error "__cpp_lib_exchange_function should have the value 201304L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_execution
+#     error "__cpp_lib_execution should be defined in c++2a"
+#   endif
+#   if __cpp_lib_execution != 201603L
+#     error "__cpp_lib_execution should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_execution
+#     error "__cpp_lib_execution should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_filesystem
+#   error "__cpp_lib_filesystem should be defined in c++2a"
+# endif
+# if __cpp_lib_filesystem != 201703L
+#   error "__cpp_lib_filesystem should have the value 201703L in c++2a"
+# endif
+
+# ifndef __cpp_lib_gcd_lcm
+#   error "__cpp_lib_gcd_lcm should be defined in c++2a"
+# endif
+# if __cpp_lib_gcd_lcm != 201606L
+#   error "__cpp_lib_gcd_lcm should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_generic_associative_lookup
+#   error "__cpp_lib_generic_associative_lookup should be defined in c++2a"
+# endif
+# if __cpp_lib_generic_associative_lookup != 201304L
+#   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_generic_unordered_lookup
+#     error "__cpp_lib_generic_unordered_lookup should be defined in c++2a"
+#   endif
+#   if __cpp_lib_generic_unordered_lookup != 201811L
+#     error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_generic_unordered_lookup
+#     error "__cpp_lib_generic_unordered_lookup should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_hardware_interference_size
+#   error "__cpp_lib_hardware_interference_size should be defined in c++2a"
+# endif
+# if __cpp_lib_hardware_interference_size != 201703L
+#   error "__cpp_lib_hardware_interference_size should have the value 201703L in c++2a"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700
+#   ifndef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should be defined in c++2a"
+#   endif
+#   if __cpp_lib_has_unique_object_representations != 201606L
+#     error "__cpp_lib_has_unique_object_representations should have the value 201606L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_has_unique_object_representations
+#     error "__cpp_lib_has_unique_object_representations should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700 is not defined!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_hypot
+#   error "__cpp_lib_hypot should be defined in c++2a"
+# endif
+# if __cpp_lib_hypot != 201603L
+#   error "__cpp_lib_hypot should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_incomplete_container_elements
+#   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
+# endif
+# if __cpp_lib_incomplete_container_elements != 201505L
+#   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
+# endif
+
+# ifndef __cpp_lib_integer_sequence
+#   error "__cpp_lib_integer_sequence should be defined in c++2a"
+# endif
+# if __cpp_lib_integer_sequence != 201304L
+#   error "__cpp_lib_integer_sequence should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_integral_constant_callable
+#   error "__cpp_lib_integral_constant_callable should be defined in c++2a"
+# endif
+# if __cpp_lib_integral_constant_callable != 201304L
+#   error "__cpp_lib_integral_constant_callable should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_invoke
+#   error "__cpp_lib_invoke should be defined in c++2a"
+# endif
+# if __cpp_lib_invoke != 201411L
+#   error "__cpp_lib_invoke should have the value 201411L in c++2a"
+# endif
+
+# if TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001
+#   ifndef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should be defined in c++2a"
+#   endif
+#   if __cpp_lib_is_aggregate != 201703L
+#     error "__cpp_lib_is_aggregate should have the value 201703L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_is_aggregate
+#     error "__cpp_lib_is_aggregate should not be defined when TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001 is not defined!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_is_constant_evaluated
+#     error "__cpp_lib_is_constant_evaluated should be defined in c++2a"
+#   endif
+#   if __cpp_lib_is_constant_evaluated != 201811L
+#     error "__cpp_lib_is_constant_evaluated should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_is_constant_evaluated
+#     error "__cpp_lib_is_constant_evaluated should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_is_final
+#   error "__cpp_lib_is_final should be defined in c++2a"
+# endif
+# if __cpp_lib_is_final != 201402L
+#   error "__cpp_lib_is_final should have the value 201402L in c++2a"
+# endif
+
+# ifndef __cpp_lib_is_invocable
+#   error "__cpp_lib_is_invocable should be defined in c++2a"
+# endif
+# if __cpp_lib_is_invocable != 201703L
+#   error "__cpp_lib_is_invocable should have the value 201703L in c++2a"
+# endif
+
+# ifndef __cpp_lib_is_null_pointer
+#   error "__cpp_lib_is_null_pointer should be defined in c++2a"
+# endif
+# if __cpp_lib_is_null_pointer != 201309L
+#   error "__cpp_lib_is_null_pointer should have the value 201309L in c++2a"
+# endif
+
+# ifndef __cpp_lib_is_swappable
+#   error "__cpp_lib_is_swappable should be defined in c++2a"
+# endif
+# if __cpp_lib_is_swappable != 201603L
+#   error "__cpp_lib_is_swappable should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_launder
+#   error "__cpp_lib_launder should be defined in c++2a"
+# endif
+# if __cpp_lib_launder != 201606L
+#   error "__cpp_lib_launder should have the value 201606L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_list_remove_return_type
+#     error "__cpp_lib_list_remove_return_type should be defined in c++2a"
+#   endif
+#   if __cpp_lib_list_remove_return_type != 201806L
+#     error "__cpp_lib_list_remove_return_type should have the value 201806L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_list_remove_return_type
+#     error "__cpp_lib_list_remove_return_type should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_logical_traits
+#   error "__cpp_lib_logical_traits should be defined in c++2a"
+# endif
+# if __cpp_lib_logical_traits != 201510L
+#   error "__cpp_lib_logical_traits should have the value 201510L in c++2a"
+# endif
+
+# ifndef __cpp_lib_make_from_tuple
+#   error "__cpp_lib_make_from_tuple should be defined in c++2a"
+# endif
+# if __cpp_lib_make_from_tuple != 201606L
+#   error "__cpp_lib_make_from_tuple should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_make_reverse_iterator
+#   error "__cpp_lib_make_reverse_iterator should be defined in c++2a"
+# endif
+# if __cpp_lib_make_reverse_iterator != 201402L
+#   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++2a"
+# endif
+
+# ifndef __cpp_lib_make_unique
+#   error "__cpp_lib_make_unique should be defined in c++2a"
+# endif
+# if __cpp_lib_make_unique != 201304L
+#   error "__cpp_lib_make_unique should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_map_try_emplace
+#   error "__cpp_lib_map_try_emplace should be defined in c++2a"
+# endif
+# if __cpp_lib_map_try_emplace != 201411L
+#   error "__cpp_lib_map_try_emplace should have the value 201411L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should be defined in c++2a"
+#   endif
+#   if __cpp_lib_math_special_functions != 201603L
+#     error "__cpp_lib_math_special_functions should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_math_special_functions
+#     error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should be defined in c++2a"
+#   endif
+#   if __cpp_lib_memory_resource != 201603L
+#     error "__cpp_lib_memory_resource should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_memory_resource
+#     error "__cpp_lib_memory_resource should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_node_extract
+#   error "__cpp_lib_node_extract should be defined in c++2a"
+# endif
+# if __cpp_lib_node_extract != 201606L
+#   error "__cpp_lib_node_extract should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_nonmember_container_access
+#   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
+# endif
+# if __cpp_lib_nonmember_container_access != 201411L
+#   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_not_fn
+#   error "__cpp_lib_not_fn should be defined in c++2a"
+# endif
+# if __cpp_lib_not_fn != 201603L
+#   error "__cpp_lib_not_fn should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_null_iterators
+#   error "__cpp_lib_null_iterators should be defined in c++2a"
+# endif
+# if __cpp_lib_null_iterators != 201304L
+#   error "__cpp_lib_null_iterators should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_optional
+#   error "__cpp_lib_optional should be defined in c++2a"
+# endif
+# if __cpp_lib_optional != 201606L
+#   error "__cpp_lib_optional should have the value 201606L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should be defined in c++2a"
+#   endif
+#   if __cpp_lib_parallel_algorithm != 201603L
+#     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_parallel_algorithm
+#     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_quoted_string_io
+#   error "__cpp_lib_quoted_string_io should be defined in c++2a"
+# endif
+# if __cpp_lib_quoted_string_io != 201304L
+#   error "__cpp_lib_quoted_string_io should have the value 201304L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should be defined in c++2a"
+#   endif
+#   if __cpp_lib_ranges != 201811L
+#     error "__cpp_lib_ranges should have the value 201811L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges
+#     error "__cpp_lib_ranges should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_raw_memory_algorithms
+#   error "__cpp_lib_raw_memory_algorithms should be defined in c++2a"
+# endif
+# if __cpp_lib_raw_memory_algorithms != 201606L
+#   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_result_of_sfinae
+#   error "__cpp_lib_result_of_sfinae should be defined in c++2a"
+# endif
+# if __cpp_lib_result_of_sfinae != 201210L
+#   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++2a"
+# endif
+
+# ifndef __cpp_lib_robust_nonmodifying_seq_ops
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++2a"
+# endif
+# if __cpp_lib_robust_nonmodifying_seq_ops != 201304L
+#   error "__cpp_lib_robust_nonmodifying_seq_ops should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_sample
+#   error "__cpp_lib_sample should be defined in c++2a"
+# endif
+# if __cpp_lib_sample != 201603L
+#   error "__cpp_lib_sample should have the value 201603L in c++2a"
+# endif
+
+# ifndef __cpp_lib_scoped_lock
+#   error "__cpp_lib_scoped_lock should be defined in c++2a"
+# endif
+# if __cpp_lib_scoped_lock != 201703L
+#   error "__cpp_lib_scoped_lock should have the value 201703L in c++2a"
+# endif
+
+# ifndef __cpp_lib_shared_mutex
+#   error "__cpp_lib_shared_mutex should be defined in c++2a"
+# endif
+# if __cpp_lib_shared_mutex != 201505L
+#   error "__cpp_lib_shared_mutex should have the value 201505L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should be defined in c++2a"
+#   endif
+#   if __cpp_lib_shared_ptr_arrays != 201611L
+#     error "__cpp_lib_shared_ptr_arrays should have the value 201611L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_shared_ptr_arrays
+#     error "__cpp_lib_shared_ptr_arrays should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_shared_ptr_weak_type
+#   error "__cpp_lib_shared_ptr_weak_type should be defined in c++2a"
+# endif
+# if __cpp_lib_shared_ptr_weak_type != 201606L
+#   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_shared_timed_mutex
+#   error "__cpp_lib_shared_timed_mutex should be defined in c++2a"
+# endif
+# if __cpp_lib_shared_timed_mutex != 201402L
+#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++2a"
+# endif
+
+# ifndef __cpp_lib_string_udls
+#   error "__cpp_lib_string_udls should be defined in c++2a"
+# endif
+# if __cpp_lib_string_udls != 201304L
+#   error "__cpp_lib_string_udls should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_string_view
+#   error "__cpp_lib_string_view should be defined in c++2a"
+# endif
+# if __cpp_lib_string_view != 201606L
+#   error "__cpp_lib_string_view should have the value 201606L in c++2a"
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_three_way_comparison
+#     error "__cpp_lib_three_way_comparison should be defined in c++2a"
+#   endif
+#   if __cpp_lib_three_way_comparison != 201711L
+#     error "__cpp_lib_three_way_comparison should have the value 201711L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_three_way_comparison
+#     error "__cpp_lib_three_way_comparison should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should be defined in c++2a"
+#   endif
+#   if __cpp_lib_to_chars != 201611L
+#     error "__cpp_lib_to_chars should have the value 201611L in c++2a"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_to_chars
+#     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# ifndef __cpp_lib_transformation_trait_aliases
+#   error "__cpp_lib_transformation_trait_aliases should be defined in c++2a"
+# endif
+# if __cpp_lib_transformation_trait_aliases != 201304L
+#   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_transparent_operators
+#   error "__cpp_lib_transparent_operators should be defined in c++2a"
+# endif
+# if __cpp_lib_transparent_operators != 201510L
+#   error "__cpp_lib_transparent_operators should have the value 201510L in c++2a"
+# endif
+
+# ifndef __cpp_lib_tuple_element_t
+#   error "__cpp_lib_tuple_element_t should be defined in c++2a"
+# endif
+# if __cpp_lib_tuple_element_t != 201402L
+#   error "__cpp_lib_tuple_element_t should have the value 201402L in c++2a"
+# endif
+
+# ifndef __cpp_lib_tuples_by_type
+#   error "__cpp_lib_tuples_by_type should be defined in c++2a"
+# endif
+# if __cpp_lib_tuples_by_type != 201304L
+#   error "__cpp_lib_tuples_by_type should have the value 201304L in c++2a"
+# endif
+
+# ifndef __cpp_lib_type_trait_variable_templates
+#   error "__cpp_lib_type_trait_variable_templates should be defined in c++2a"
+# endif
+# if __cpp_lib_type_trait_variable_templates != 201510L
+#   error "__cpp_lib_type_trait_variable_templates should have the value 201510L in c++2a"
+# endif
+
+# ifndef __cpp_lib_uncaught_exceptions
+#   error "__cpp_lib_uncaught_exceptions should be defined in c++2a"
+# endif
+# if __cpp_lib_uncaught_exceptions != 201411L
+#   error "__cpp_lib_uncaught_exceptions should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_unordered_map_try_emplace
+#   error "__cpp_lib_unordered_map_try_emplace should be defined in c++2a"
+# endif
+# if __cpp_lib_unordered_map_try_emplace != 201411L
+#   error "__cpp_lib_unordered_map_try_emplace should have the value 201411L in c++2a"
+# endif
+
+# ifndef __cpp_lib_variant
+#   error "__cpp_lib_variant should be defined in c++2a"
+# endif
+# if __cpp_lib_variant != 201606L
+#   error "__cpp_lib_variant should have the value 201606L in c++2a"
+# endif
+
+# ifndef __cpp_lib_void_t
+#   error "__cpp_lib_void_t should be defined in c++2a"
+# endif
+# if __cpp_lib_void_t != 201411L
+#   error "__cpp_lib_void_t should have the value 201411L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main() {}
diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index 997555296..5af072471 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -69,6 +69,7 @@
 #define TEST_CLANG_VER (__clang_major__ * 100) + __clang_minor__
 #elif defined(__GNUC__)
 #define TEST_GCC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
+#define TEST_GCC_VER_NEW (TEST_GCC_VER * 10 + __GNUC_PATCHLEVEL__)
 #endif
 
 /* Make a nice name for the standard version */
-- 
GitLab


From 272871b658429a2da4c28ddecbfbe7574f781a7f Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 16 Jan 2019 01:51:12 +0000
Subject: [PATCH 047/137] Move internal usages of `alignof`/`__alignof` to use
 `_LIBCPP_ALIGNOF`.

Summary:
Starting in Clang 8.0 and GCC 8.0, `alignof` and `__alignof` return different values in same cases. Specifically `alignof` and `_Alignof` return the minimum alignment for a type, where as `__alignof` returns the preferred alignment. libc++ currently uses `__alignof` but means to use `alignof`. See  llvm.org/PR39713

This patch introduces the macro `_LIBCPP_ALIGNOF` so we can control which spelling gets used.

This patch does not introduce any ABI guard to provide the old behavior with newer compilers. However, if we decide that is needed, this patch makes it trivial to implement.

I think we should commit this change immediately, and decide what we want to do about the ABI afterwards.

Reviewers: ldionne, EricWF

Reviewed By: ldionne, EricWF

Subscribers: jyknight, christof, libcxx-commits

Differential Revision: https://reviews.llvm.org/D54814

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351289 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/__config                              | 18 +++++++--
 include/__sso_allocator                       |  4 +-
 include/experimental/coroutine                |  6 +--
 include/experimental/memory_resource          |  8 ++--
 include/functional                            |  2 +-
 include/memory                                | 16 ++++----
 include/type_traits                           |  8 ++--
 include/valarray                              | 40 +++++++++----------
 test/libcxx/libcpp_alignof.pass.cpp           | 37 +++++++++++++++++
 .../array/size_and_alignment.pass.cpp         |  2 -
 .../meta.trans.other/aligned_storage.pass.cpp |  9 ++---
 .../alignment_of.pass.cpp                     |  8 +++-
 test/support/test_macros.h                    |  6 ++-
 13 files changed, 109 insertions(+), 55 deletions(-)
 create mode 100644 test/libcxx/libcpp_alignof.pass.cpp

diff --git a/include/__config b/include/__config
index e82d7fec5..f0bc3483f 100644
--- a/include/__config
+++ b/include/__config
@@ -353,6 +353,18 @@
 #  endif // __linux__
 #endif
 
+#ifndef _LIBCPP_CXX03_LANG
+# define _LIBCPP_ALIGNOF(_Tp) alignof(_Tp)
+#elif defined(_LIBCPP_COMPILER_CLANG)
+# define _LIBCPP_ALIGNOF(_Tp) _Alignof(_Tp)
+#else
+// This definition is potentially buggy, but it's only taken with GCC in C++03,
+// which we barely support anyway. See llvm.org/PR39713
+# define _LIBCPP_ALIGNOF(_Tp) __alignof(_Tp)
+#endif
+
+#define _LIBCPP_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
+
 #if defined(_LIBCPP_COMPILER_CLANG)
 
 // _LIBCPP_ALTERNATE_STRING_LAYOUT is an old name for
@@ -367,7 +379,7 @@
 #  define _ALIGNAS_TYPE(x) alignas(x)
 #  define _ALIGNAS(x) alignas(x)
 #else
-#  define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
+#  define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
 #  define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #endif
 
@@ -494,7 +506,7 @@ typedef __char32_t char32_t;
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
-#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
+#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
 
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
@@ -607,7 +619,7 @@ typedef __char32_t char32_t;
 #elif defined(_LIBCPP_COMPILER_IBM)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
-#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
+#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
 #define _ATTRIBUTE(x) __attribute__((x))
 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
diff --git a/include/__sso_allocator b/include/__sso_allocator
index e16b680ec..8aca0495d 100644
--- a/include/__sso_allocator
+++ b/include/__sso_allocator
@@ -55,14 +55,14 @@ public:
             __allocated_ = true;
             return (pointer)&buf_;
         }
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
+        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n)
     {
         if (__p == (pointer)&buf_)
             __allocated_ = false;
         else
-            _VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), __alignof(_Tp));
+            _VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
     }
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}
 
diff --git a/include/experimental/coroutine b/include/experimental/coroutine
index 1eb224a53..7cb39b81b 100644
--- a/include/experimental/coroutine
+++ b/include/experimental/coroutine
@@ -214,7 +214,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     _Promise& promise() const {
         return *static_cast<_Promise*>(
-            __builtin_coro_promise(this->__handle_, __alignof(_Promise), false));
+            __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
     }
 
 public:
@@ -254,7 +254,7 @@ public:
         coroutine_handle __tmp;
         __tmp.__handle_ = __builtin_coro_promise(
             _VSTD::addressof(const_cast<_RawPromise&>(__promise)),
-             __alignof(_Promise), true);
+             _LIBCPP_ALIGNOF(_Promise), true);
         return __tmp;
     }
 };
@@ -272,7 +272,7 @@ public:
   _LIBCPP_INLINE_VISIBILITY
   _Promise& promise() const {
     return *static_cast<_Promise*>(
-      __builtin_coro_promise(this->__handle_, __alignof(_Promise), false));
+      __builtin_coro_promise(this->__handle_, _LIBCPP_ALIGNOF(_Promise), false));
   }
 
   _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; }
diff --git a/include/experimental/memory_resource b/include/experimental/memory_resource
index 221ce5b8e..83781d462 100644
--- a/include/experimental/memory_resource
+++ b/include/experimental/memory_resource
@@ -98,7 +98,7 @@ size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
 // 8.5, memory.resource
 class _LIBCPP_TYPE_VIS memory_resource
 {
-    static const size_t __max_align = alignof(max_align_t);
+    static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t);
 
 // 8.5.2, memory.resource.public
 public:
@@ -190,7 +190,7 @@ public:
                 " 'n' exceeds maximum supported size");
         }
         return static_cast<_ValueType*>(
-            __res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
+            __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType))
         );
     }
 
@@ -198,7 +198,7 @@ public:
     void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
         _LIBCPP_ASSERT(__n <= __max_size(),
                        "deallocate called for size which exceeds max_size()");
-        __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
+        __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType));
     }
 
     template <class _Tp, class ..._Ts>
@@ -345,7 +345,7 @@ class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
                && is_same<typename _CTraits::pointer, char*>::value
                && is_same<typename _CTraits::void_pointer, void*>::value, "");
 
-    static const size_t _MaxAlign = alignof(max_align_t);
+    static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t);
 
     using _Alloc = typename _CTraits::template rebind_alloc<
             typename aligned_storage<_MaxAlign, _MaxAlign>::type
diff --git a/include/functional b/include/functional
index 1fb44f271..95491879b 100644
--- a/include/functional
+++ b/include/functional
@@ -1872,7 +1872,7 @@ template <typename _Fun>
 struct __use_small_storage
     : public _VSTD::integral_constant<
           bool, sizeof(_Fun) <= sizeof(__policy_storage) &&
-                    alignof(_Fun) <= alignof(__policy_storage) &&
+                    _LIBCPP_ALIGNOF(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage) &&
                     _VSTD::is_trivially_copy_constructible<_Fun>::value &&
                     _VSTD::is_trivially_destructible<_Fun>::value> {};
 
diff --git a/include/memory b/include/memory
index 93f04c6fa..ce2c35766 100644
--- a/include/memory
+++ b/include/memory
@@ -1811,10 +1811,10 @@ public:
         if (__n > max_size())
             __throw_length_error("allocator<T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
+        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
         }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
-        {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), __alignof(_Tp));}
+        {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
@@ -1912,10 +1912,10 @@ public:
         if (__n > max_size())
             __throw_length_error("allocator<const T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
+        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
-        {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), __alignof(_Tp));}
+        {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
@@ -2031,7 +2031,7 @@ get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
     while (__n > 0)
     {
 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-    if (__is_overaligned_for_new(__alignof(_Tp)))
+    if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp)))
         {
             std::align_val_t __al =
                 std::align_val_t(std::alignment_of<_Tp>::value);
@@ -2042,7 +2042,7 @@ get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
                 __n * sizeof(_Tp), nothrow));
         }
 #else
-    if (__is_overaligned_for_new(__alignof(_Tp)))
+    if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp)))
         {
             // Since aligned operator new is unavailable, return an empty
             // buffer rather than one with invalid alignment.
@@ -2066,7 +2066,7 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void return_temporary_buffer(_Tp* __p) _NOEXCEPT
 {
-  _VSTD::__libcpp_deallocate_unsized((void*)__p, __alignof(_Tp));
+  _VSTD::__libcpp_deallocate_unsized((void*)__p, _LIBCPP_ALIGNOF(_Tp));
 }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
@@ -5642,7 +5642,7 @@ template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
 
-    typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __v;
+    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
     _Alloc &__a;
 
     _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
diff --git a/include/type_traits b/include/type_traits
index ab010716f..8b30511a4 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -1652,7 +1652,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool has_unique_object_representations_v
 // alignment_of
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
-    : public integral_constant<size_t, __alignof__(_Tp)> {};
+    : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
@@ -1682,7 +1682,7 @@ struct __nat
 template <class _Tp>
 struct __align_type
 {
-    static const size_t value = alignment_of<_Tp>::value;
+    static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);
     typedef _Tp type;
 };
 
@@ -1815,8 +1815,8 @@ struct __static_max<_I0, _I1, _In...>
 template <size_t _Len, class _Type0, class ..._Types>
 struct aligned_union
 {
-    static const size_t alignment_value = __static_max<__alignof__(_Type0),
-                                                       __alignof__(_Types)...>::value;
+    static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0),
+                                                       _LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value;
     static const size_t __len = __static_max<_Len, sizeof(_Type0),
                                              sizeof(_Types)...>::value;
     typedef typename aligned_storage<__len, alignment_value>::type type;
diff --git a/include/valarray b/include/valarray
index 3188b6af4..07f38c811 100644
--- a/include/valarray
+++ b/include/valarray
@@ -2740,7 +2740,7 @@ __val_expr<_ValExpr>::operator valarray<__val_expr::result_type>() const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<result_type*>(
-                    _VSTD::__libcpp_allocate(__n * sizeof(result_type), __alignof(result_type)));
+                    _VSTD::__libcpp_allocate(__n * sizeof(result_type), _LIBCPP_ALIGNOF(result_type)));
         for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
             ::new (__r.__end_) result_type(__expr_[__i]);
     }
@@ -2758,7 +2758,7 @@ valarray<_Tp>::valarray(size_t __n)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-            _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+            _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -2793,7 +2793,7 @@ valarray<_Tp>::valarray(const value_type* __p, size_t __n)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-            _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+            _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -2819,7 +2819,7 @@ valarray<_Tp>::valarray(const valarray& __v)
     if (__v.size())
     {
         __begin_ = __end_ = static_cast<value_type*>(
-            _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), __alignof(value_type)));
+            _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -2857,7 +2857,7 @@ valarray<_Tp>::valarray(initializer_list<value_type> __il)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-_VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+_VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -2887,7 +2887,7 @@ valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-          _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+          _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -2915,7 +2915,7 @@ valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -2945,7 +2945,7 @@ valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -2975,7 +2975,7 @@ valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
@@ -3012,7 +3012,7 @@ valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l)
     {
         __clear(size());
         __begin_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         __end_ = __begin_ + __n;
         _VSTD::uninitialized_copy(__f, __l, __begin_);
     } else {
@@ -3268,7 +3268,7 @@ valarray<_Tp>::operator+() const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(+*__p);
     }
@@ -3286,7 +3286,7 @@ valarray<_Tp>::operator-() const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(-*__p);
     }
@@ -3304,7 +3304,7 @@ valarray<_Tp>::operator~() const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(~*__p);
     }
@@ -3321,7 +3321,7 @@ valarray<_Tp>::operator!() const
     {
         __r.__begin_ =
             __r.__end_ =
-                static_cast<bool*>(_VSTD::__libcpp_allocate(__n * sizeof(bool), __alignof(bool)));
+                static_cast<bool*>(_VSTD::__libcpp_allocate(__n * sizeof(bool), _LIBCPP_ALIGNOF(bool)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) bool(!*__p);
     }
@@ -3642,7 +3642,7 @@ valarray<_Tp>::shift(int __i) const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         const value_type* __sb;
         value_type* __tb;
         value_type* __te;
@@ -3681,7 +3681,7 @@ valarray<_Tp>::cshift(int __i) const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         __i %= static_cast<int>(__n);
         const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
         for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
@@ -3703,7 +3703,7 @@ valarray<_Tp>::apply(value_type __f(value_type)) const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(__f(*__p));
     }
@@ -3721,7 +3721,7 @@ valarray<_Tp>::apply(value_type __f(const value_type&)) const
         __r.__begin_ =
             __r.__end_ =
                 static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(__f(*__p));
     }
@@ -3736,7 +3736,7 @@ void valarray<_Tp>::__clear(size_t __capacity)
   {
     while (__end_ != __begin_)
       (--__end_)->~value_type();
-    _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), __alignof(value_type));
+    _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), _LIBCPP_ALIGNOF(value_type));
     __begin_ = __end_ = nullptr;
   }
 }
@@ -3749,7 +3749,7 @@ valarray<_Tp>::resize(size_t __n, value_type __x)
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(
-           _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
+           _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
diff --git a/test/libcxx/libcpp_alignof.pass.cpp b/test/libcxx/libcpp_alignof.pass.cpp
new file mode 100644
index 000000000..ba0df807e
--- /dev/null
+++ b/test/libcxx/libcpp_alignof.pass.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// Test that _LIBCPP_ALIGNOF acts the same as the C++11 keyword `alignof`, and
+// not as the GNU extension `__alignof`. The former returns the minimal required
+// alignment for a type, whereas the latter returns the preferred alignment.
+//
+// See llvm.org/PR39713
+
+#include <type_traits>
+#include "test_macros.h"
+
+template <class T>
+void test() {
+  static_assert(_LIBCPP_ALIGNOF(T) == std::alignment_of<T>::value, "");
+  static_assert(_LIBCPP_ALIGNOF(T) == TEST_ALIGNOF(T), "");
+#if TEST_STD_VER >= 11
+  static_assert(_LIBCPP_ALIGNOF(T) == alignof(T), "");
+#endif
+#ifdef TEST_COMPILER_CLANG
+  static_assert(_LIBCPP_ALIGNOF(T) == _Alignof(T), "");
+#endif
+}
+
+int main() {
+  test<int>();
+  test<long long>();
+  test<double>();
+  test<long double>();
+}
diff --git a/test/std/containers/sequences/array/size_and_alignment.pass.cpp b/test/std/containers/sequences/array/size_and_alignment.pass.cpp
index 966d063fe..d73182bd5 100644
--- a/test/std/containers/sequences/array/size_and_alignment.pass.cpp
+++ b/test/std/containers/sequences/array/size_and_alignment.pass.cpp
@@ -58,8 +58,6 @@ struct TEST_ALIGNAS(TEST_ALIGNOF(std::max_align_t) * 2) TestType2 {
   char data[1000];
 };
 
-//static_assert(sizeof(void*) == 4, "");
-
 int main() {
   test_type<char>();
   test_type<int>();
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
index d7e35a62f..012741ff6 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
@@ -254,9 +254,6 @@ int main()
     // Use alignof(std::max_align_t) below to find the max alignment instead of
     // hardcoding it, because it's different on different platforms.
     // (For example 8 on arm and 16 on x86.)
-#if TEST_STD_VER < 11
-#define alignof __alignof__
-#endif
     {
     typedef std::aligned_storage<16>::type T1;
 #if TEST_STD_VER > 11
@@ -264,7 +261,7 @@ int main()
 #endif
     static_assert(std::is_trivial<T1>::value, "");
     static_assert(std::is_standard_layout<T1>::value, "");
-    static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
+    static_assert(std::alignment_of<T1>::value == TEST_ALIGNOF(std::max_align_t),
                   "");
     static_assert(sizeof(T1) == 16, "");
     }
@@ -275,9 +272,9 @@ int main()
 #endif
     static_assert(std::is_trivial<T1>::value, "");
     static_assert(std::is_standard_layout<T1>::value, "");
-    static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
+    static_assert(std::alignment_of<T1>::value == TEST_ALIGNOF(std::max_align_t),
                   "");
-    static_assert(sizeof(T1) == 16 + alignof(std::max_align_t), "");
+    static_assert(sizeof(T1) == 16 + TEST_ALIGNOF(std::max_align_t), "");
     }
     {
     typedef std::aligned_storage<10>::type T1;
diff --git a/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
index 0f55db647..bd02da969 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
@@ -19,6 +19,9 @@
 template <class T, unsigned A>
 void test_alignment_of()
 {
+    const unsigned AlignofResult = TEST_ALIGNOF(T);
+    static_assert( AlignofResult == A, "Golden value does not match result of alignof keyword");
+    static_assert( std::alignment_of<T>::value == AlignofResult, "");
     static_assert( std::alignment_of<T>::value == A, "");
     static_assert( std::alignment_of<const T>::value == A, "");
     static_assert( std::alignment_of<volatile T>::value == A, "");
@@ -45,7 +48,10 @@ int main()
     test_alignment_of<const int*, sizeof(intptr_t)>();
     test_alignment_of<char[3], 1>();
     test_alignment_of<int, 4>();
-    test_alignment_of<double, 8>();
+    // The test case below is a hack. It's hard to detect what golden value
+    // we should expect. In most cases it should be 8. But in i386 builds
+    // with Clang >= 8 or GCC >= 8 the value is '4'.
+    test_alignment_of<double, TEST_ALIGNOF(double)>();
 #if (defined(__ppc__) && !defined(__ppc64__))
     test_alignment_of<bool, 4>();   // 32-bit PPC has four byte bool
 #else
diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index 5af072471..2813d1ff0 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -116,7 +116,11 @@
 #   define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 # endif
 #else
-#define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
+#if defined(TEST_COMPILER_CLANG)
+# define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__)
+#else
+# define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
+#endif
 #define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
 #define TEST_CONSTEXPR
 #define TEST_CONSTEXPR_CXX14
-- 
GitLab


From 6840e5476ec952ebfb499481122724ac003378c7 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 16 Jan 2019 01:54:34 +0000
Subject: [PATCH 048/137] Fix PR40230 - std::pair may have padding on FreeBSD.

Summary:
FreeBSD ships a very old and deprecated ABI for std::pair where the copy and move constructors are not allowed to be trivial. D25389 change how this was implemented by introducing a non-trivial base class. This patch, introduced in October 2016, introduced an ABI bug that caused nested `std::pair` instantiations to have padding. For example:

```
using PairT = std::pair< std::pair<char, char>, char >;
static_assert(offsetof(PairT, first) == 0, "First member should exist at offset zero"); // Fails on FreeBSD!
```

The bug occurs because the base class for the first element (the nested pair) cannot be put at offset zero because the top-level pair already has the same base class laid out there.

This patch fixes that ABI bug by templating the dummy base class on the same parameters as the pair.

Technically this fix is an ABI break for users who depend on the "broken" ABI introduced in 2016. I'm putting this up for review so that the FreeBSD maintainers can sign off on fixing the ABI by breaking the ABI.
Another option, since we have to "break" the ABI to fix it, would be to move FreeBSD off the deprecated non-trivial pair ABI instead.

Also see:

* https://llvm.org/PR40230
* https://reviews.llvm.org/D21329



Reviewers: rsmith, dim, emaste

Reviewed By: rsmith

Subscribers: mclow.lists, krytarowski, christof, ldionne, libcxx-commits

Differential Revision: https://reviews.llvm.org/D56357

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351290 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/utility                                   |  3 ++-
 .../pairs.pair/non_trivial_copy_move_ABI.pass.cpp | 15 ++++++++++++++-
 .../pairs.pair/trivial_copy_move_ABI.pass.cpp     | 15 ++++++++++++++-
 3 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/include/utility b/include/utility
index 3fa0bc4c7..74bbc5cf3 100644
--- a/include/utility
+++ b/include/utility
@@ -303,6 +303,7 @@ extern _LIBCPP_EXPORTED_FROM_ABI const piecewise_construct_t piecewise_construct
 #endif
 
 #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
+template <class, class>
 struct __non_trivially_copyable_base {
   _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
   __non_trivially_copyable_base() _NOEXCEPT {}
@@ -314,7 +315,7 @@ struct __non_trivially_copyable_base {
 template <class _T1, class _T2>
 struct _LIBCPP_TEMPLATE_VIS pair
 #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
-: private __non_trivially_copyable_base
+: private __non_trivially_copyable_base<_T1, _T2>
 #endif
 {
     typedef _T1 first_type;
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
index 8b5969d51..58ea6ecde 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
@@ -30,6 +30,7 @@
 #include <utility>
 #include <type_traits>
 #include <cstdlib>
+#include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
@@ -86,7 +87,7 @@ static_assert(!HasNonTrivialABI<Trivial>::value, "");
 #endif
 
 
-int main()
+void test_trivial()
 {
     {
         typedef std::pair<int, short> P;
@@ -150,3 +151,15 @@ int main()
     }
 #endif
 }
+
+void test_layout() {
+    typedef std::pair<std::pair<char, char>, char> PairT;
+    static_assert(sizeof(PairT) == 3, "");
+    static_assert(TEST_ALIGNOF(PairT) == TEST_ALIGNOF(char), "");
+    static_assert(offsetof(PairT, first) == 0, "");
+}
+
+int main() {
+    test_trivial();
+    test_layout();
+}
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
index ec9cc7ec3..734623388 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
@@ -25,6 +25,7 @@
 #include <utility>
 #include <type_traits>
 #include <cstdlib>
+#include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
@@ -81,7 +82,7 @@ static_assert(HasTrivialABI<Trivial>::value, "");
 #endif
 
 
-int main()
+void test_trivial()
 {
     {
         typedef std::pair<int, short> P;
@@ -145,3 +146,15 @@ int main()
     }
 #endif
 }
+
+void test_layout() {
+    typedef std::pair<std::pair<char, char>, char> PairT;
+    static_assert(sizeof(PairT) == 3, "");
+    static_assert(TEST_ALIGNOF(PairT) == TEST_ALIGNOF(char), "");
+    static_assert(offsetof(PairT, first) == 0, "");
+}
+
+int main() {
+    test_trivial();
+    test_layout();
+}
-- 
GitLab


From 8290a8d27164174f9076c3c50affc179f1789961 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 16 Jan 2019 02:10:28 +0000
Subject: [PATCH 049/137] Fix feature test macros for atomics/mutexes without
 threading

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351291 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/version                               |  16 ++-
 .../atomic.version.pass.cpp                   |  34 ++++--
 .../generate_feature_test_macro_components.py |  22 +++-
 .../shared_mutex.version.pass.cpp             |  82 +++++++++----
 .../version.version.pass.cpp                  | 112 ++++++++++++------
 5 files changed, 189 insertions(+), 77 deletions(-)

diff --git a/include/version b/include/version
index d37aba139..e37afc448 100644
--- a/include/version
+++ b/include/version
@@ -135,7 +135,9 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_quoted_string_io                     201304L
 # define __cpp_lib_result_of_sfinae                     201210L
 # define __cpp_lib_robust_nonmodifying_seq_ops          201304L
-# define __cpp_lib_shared_timed_mutex                   201402L
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   define __cpp_lib_shared_timed_mutex                 201402L
+# endif
 # define __cpp_lib_string_udls                          201304L
 # define __cpp_lib_transformation_trait_aliases         201304L
 # define __cpp_lib_transparent_operators                201210L
@@ -152,7 +154,9 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_apply                                201603L
 # define __cpp_lib_array_constexpr                      201603L
 # define __cpp_lib_as_const                             201510L
-# define __cpp_lib_atomic_is_always_lock_free           201603L
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   define __cpp_lib_atomic_is_always_lock_free         201603L
+# endif
 # define __cpp_lib_bool_constant                        201505L
 // # define __cpp_lib_boyer_moore_searcher                 201603L
 # define __cpp_lib_byte                                 201603L
@@ -188,7 +192,9 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_raw_memory_algorithms                201606L
 # define __cpp_lib_sample                               201603L
 # define __cpp_lib_scoped_lock                          201703L
-# define __cpp_lib_shared_mutex                         201505L
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   define __cpp_lib_shared_mutex                       201505L
+# endif
 // # define __cpp_lib_shared_ptr_arrays                    201611L
 # define __cpp_lib_shared_ptr_weak_type                 201606L
 # define __cpp_lib_string_view                          201606L
@@ -203,7 +209,9 @@ __cpp_lib_void_t                                        201411L <type_traits>
 #endif
 
 #if _LIBCPP_STD_VER > 17
-// # define __cpp_lib_atomic_ref                           201806L
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+// #   define __cpp_lib_atomic_ref                         201806L
+# endif
 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
diff --git a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
index 4c0b35121..4ba37542c 100644
--- a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
@@ -10,6 +10,8 @@
 // WARNING: This test was generated by generate_feature_test_macros_tests.py and
 // should not be edited manually.
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <atomic>
 
 // Test the feature test macros defined by <atomic>
@@ -53,11 +55,17 @@
 
 #elif TEST_STD_VER == 17
 
-# ifndef __cpp_lib_atomic_is_always_lock_free
-#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
-# endif
-# if __cpp_lib_atomic_is_always_lock_free != 201603L
-#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
+#   endif
+#   if __cpp_lib_atomic_is_always_lock_free != 201603L
+#     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # ifdef __cpp_lib_atomic_ref
@@ -70,11 +78,17 @@
 
 #elif TEST_STD_VER > 17
 
-# ifndef __cpp_lib_atomic_is_always_lock_free
-#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
-# endif
-# if __cpp_lib_atomic_is_always_lock_free != 201603L
-#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_is_always_lock_free != 201603L
+#     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
diff --git a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
index d51df4543..2f13ed022 100755
--- a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
+++ b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
@@ -148,14 +148,18 @@ feature_test_macros = sorted([ add_version_header(x) for x in [
    "values": {
      "c++14": 201402L,
    },
-   "headers": ["shared_mutex"]
+   "headers": ["shared_mutex"],
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
   },
   # C++17 macros
   {"name": "__cpp_lib_atomic_is_always_lock_free",
    "values": {
      "c++17": 201603L,
    },
-   "headers": ["atomic"]
+   "headers": ["atomic"],
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
   },
   {"name": "__cpp_lib_filesystem",
    "values": {
@@ -446,6 +450,8 @@ feature_test_macros = sorted([ add_version_header(x) for x in [
      "c++17": 201505L,
    },
    "headers": ["shared_mutex"],
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    },
   {"name": "__cpp_lib_scoped_lock",
    "values": {
@@ -553,6 +559,8 @@ feature_test_macros = sorted([ add_version_header(x) for x in [
    },
    "headers": ["atomic"],
    "unimplemented": True,
+   "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    },
 ]], key=lambda tc: tc["name"])
 
@@ -802,6 +810,10 @@ def generate_synopsis(test_list):
     result += "*/"
     return result
 
+def is_threading_header_unsafe_to_include(h):
+  # NOTE: "<mutex>" does not blow up when included without threads.
+  return h in ['atomic', 'shared_mutex']
+
 def produce_tests():
   headers = set([h for tc in feature_test_macros for h in tc["headers"]])
   for h in headers:
@@ -810,6 +822,9 @@ def produce_tests():
       for tc in test_list:
         assert 'unimplemented' in tc.keys()
       continue
+    test_tags = ""
+    if is_threading_header_unsafe_to_include(h):
+      test_tags += '\n// UNSUPPORTED: libcpp-has-no-threads\n'
     test_body = \
 """//===----------------------------------------------------------------------===//
 //
@@ -822,7 +837,7 @@ def produce_tests():
 //
 // WARNING: This test was generated by generate_feature_test_macros_tests.py and
 // should not be edited manually.
-
+{test_tags}
 // <{header}>
 
 // Test the feature test macros defined by <{header}>
@@ -852,6 +867,7 @@ def produce_tests():
 
 int main() {{}}
 """.format(header=h,
+           test_tags=test_tags,
            synopsis=generate_synopsis(test_list),
            cxx11_tests=generate_std_test(test_list, 'c++11').strip(),
            cxx14_tests=generate_std_test(test_list, 'c++14').strip(),
diff --git a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
index a86aebe70..98bdf704b 100644
--- a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
@@ -10,6 +10,8 @@
 // WARNING: This test was generated by generate_feature_test_macros_tests.py and
 // should not be edited manually.
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <shared_mutex>
 
 // Test the feature test macros defined by <shared_mutex>
@@ -38,43 +40,73 @@
 #   error "__cpp_lib_shared_mutex should not be defined before c++17"
 # endif
 
-# ifndef __cpp_lib_shared_timed_mutex
-#   error "__cpp_lib_shared_timed_mutex should be defined in c++14"
-# endif
-# if __cpp_lib_shared_timed_mutex != 201402L
-#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++14"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should be defined in c++14"
+#   endif
+#   if __cpp_lib_shared_timed_mutex != 201402L
+#     error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++14"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 #elif TEST_STD_VER == 17
 
-# ifndef __cpp_lib_shared_mutex
-#   error "__cpp_lib_shared_mutex should be defined in c++17"
-# endif
-# if __cpp_lib_shared_mutex != 201505L
-#   error "__cpp_lib_shared_mutex should have the value 201505L in c++17"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should be defined in c++17"
+#   endif
+#   if __cpp_lib_shared_mutex != 201505L
+#     error "__cpp_lib_shared_mutex should have the value 201505L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
-# ifndef __cpp_lib_shared_timed_mutex
-#   error "__cpp_lib_shared_timed_mutex should be defined in c++17"
-# endif
-# if __cpp_lib_shared_timed_mutex != 201402L
-#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++17"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should be defined in c++17"
+#   endif
+#   if __cpp_lib_shared_timed_mutex != 201402L
+#     error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 #elif TEST_STD_VER > 17
 
-# ifndef __cpp_lib_shared_mutex
-#   error "__cpp_lib_shared_mutex should be defined in c++2a"
-# endif
-# if __cpp_lib_shared_mutex != 201505L
-#   error "__cpp_lib_shared_mutex should have the value 201505L in c++2a"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should be defined in c++2a"
+#   endif
+#   if __cpp_lib_shared_mutex != 201505L
+#     error "__cpp_lib_shared_mutex should have the value 201505L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
-# ifndef __cpp_lib_shared_timed_mutex
-#   error "__cpp_lib_shared_timed_mutex should be defined in c++2a"
-# endif
-# if __cpp_lib_shared_timed_mutex != 201402L
-#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++2a"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should be defined in c++2a"
+#   endif
+#   if __cpp_lib_shared_timed_mutex != 201402L
+#     error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 #endif // TEST_STD_VER > 17
diff --git a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
index 6f7d649f5..27931b447 100644
--- a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -749,11 +749,17 @@
 #   error "__cpp_lib_shared_ptr_weak_type should not be defined before c++17"
 # endif
 
-# ifndef __cpp_lib_shared_timed_mutex
-#   error "__cpp_lib_shared_timed_mutex should be defined in c++14"
-# endif
-# if __cpp_lib_shared_timed_mutex != 201402L
-#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++14"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should be defined in c++14"
+#   endif
+#   if __cpp_lib_shared_timed_mutex != 201402L
+#     error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++14"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # ifndef __cpp_lib_string_udls
@@ -873,11 +879,17 @@
 #   error "__cpp_lib_as_const should have the value 201510L in c++17"
 # endif
 
-# ifndef __cpp_lib_atomic_is_always_lock_free
-#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
-# endif
-# if __cpp_lib_atomic_is_always_lock_free != 201603L
-#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++17"
+#   endif
+#   if __cpp_lib_atomic_is_always_lock_free != 201603L
+#     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # ifdef __cpp_lib_atomic_ref
@@ -1289,11 +1301,17 @@
 #   error "__cpp_lib_scoped_lock should have the value 201703L in c++17"
 # endif
 
-# ifndef __cpp_lib_shared_mutex
-#   error "__cpp_lib_shared_mutex should be defined in c++17"
-# endif
-# if __cpp_lib_shared_mutex != 201505L
-#   error "__cpp_lib_shared_mutex should have the value 201505L in c++17"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should be defined in c++17"
+#   endif
+#   if __cpp_lib_shared_mutex != 201505L
+#     error "__cpp_lib_shared_mutex should have the value 201505L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
@@ -1316,11 +1334,17 @@
 #   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++17"
 # endif
 
-# ifndef __cpp_lib_shared_timed_mutex
-#   error "__cpp_lib_shared_timed_mutex should be defined in c++17"
-# endif
-# if __cpp_lib_shared_timed_mutex != 201402L
-#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++17"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should be defined in c++17"
+#   endif
+#   if __cpp_lib_shared_timed_mutex != 201402L
+#     error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++17"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # ifndef __cpp_lib_string_udls
@@ -1467,11 +1491,17 @@
 #   error "__cpp_lib_as_const should have the value 201510L in c++2a"
 # endif
 
-# ifndef __cpp_lib_atomic_is_always_lock_free
-#   error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
-# endif
-# if __cpp_lib_atomic_is_always_lock_free != 201603L
-#   error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should be defined in c++2a"
+#   endif
+#   if __cpp_lib_atomic_is_always_lock_free != 201603L
+#     error "__cpp_lib_atomic_is_always_lock_free should have the value 201603L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_atomic_is_always_lock_free
+#     error "__cpp_lib_atomic_is_always_lock_free should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
@@ -1994,11 +2024,17 @@
 #   error "__cpp_lib_scoped_lock should have the value 201703L in c++2a"
 # endif
 
-# ifndef __cpp_lib_shared_mutex
-#   error "__cpp_lib_shared_mutex should be defined in c++2a"
-# endif
-# if __cpp_lib_shared_mutex != 201505L
-#   error "__cpp_lib_shared_mutex should have the value 201505L in c++2a"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should be defined in c++2a"
+#   endif
+#   if __cpp_lib_shared_mutex != 201505L
+#     error "__cpp_lib_shared_mutex should have the value 201505L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_mutex
+#     error "__cpp_lib_shared_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
@@ -2021,11 +2057,17 @@
 #   error "__cpp_lib_shared_ptr_weak_type should have the value 201606L in c++2a"
 # endif
 
-# ifndef __cpp_lib_shared_timed_mutex
-#   error "__cpp_lib_shared_timed_mutex should be defined in c++2a"
-# endif
-# if __cpp_lib_shared_timed_mutex != 201402L
-#   error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++2a"
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   ifndef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should be defined in c++2a"
+#   endif
+#   if __cpp_lib_shared_timed_mutex != 201402L
+#     error "__cpp_lib_shared_timed_mutex should have the value 201402L in c++2a"
+#   endif
+# else
+#   ifdef __cpp_lib_shared_timed_mutex
+#     error "__cpp_lib_shared_timed_mutex should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) is not defined!"
+#   endif
 # endif
 
 # ifndef __cpp_lib_string_udls
-- 
GitLab


From 455f16a829052a1d1283bbf9e03c65557ec0f076 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 16 Jan 2019 02:16:57 +0000
Subject: [PATCH 050/137] Attempt to make test_macros.h even more minimal

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351292 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/support/test_macros.h | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index 2813d1ff0..e45253534 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -11,7 +11,18 @@
 #ifndef SUPPORT_TEST_MACROS_HPP
 #define SUPPORT_TEST_MACROS_HPP
 
-#include <ciso646> // Get STL specific macros like _LIBCPP_VERSION
+// Attempt to get STL specific macros like _LIBCPP_VERSION using the most
+// minimal header possible. If we're testing libc++, we should use `<__config>`.
+// If <__config> isn't available, fall back to <ciso646>.
+#ifdef __has_include
+# if __has_include("<__config>")
+#   include <__config>
+#   define TEST_IMP_INCLUDED_HEADER
+# endif
+#endif
+#ifndef TEST_IMP_INCLUDED_HEADER
+#include <ciso646>
+#endif
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
-- 
GitLab


From 89e287b0aece2c3f18b660b7d5d1324e17157a8b Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Wed, 16 Jan 2019 05:43:02 +0000
Subject: [PATCH 051/137] correct script name in generated tests

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351299 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../algorithm.version.pass.cpp                       |  4 ++--
 .../support.limits.general/any.version.pass.cpp      |  4 ++--
 .../support.limits.general/array.version.pass.cpp    |  4 ++--
 .../support.limits.general/atomic.version.pass.cpp   |  4 ++--
 .../support.limits.general/bit.version.pass.cpp      |  4 ++--
 .../support.limits.general/chrono.version.pass.cpp   |  4 ++--
 .../support.limits.general/cmath.version.pass.cpp    |  4 ++--
 .../support.limits.general/compare.version.pass.cpp  |  4 ++--
 .../support.limits.general/complex.version.pass.cpp  |  4 ++--
 .../support.limits.general/cstddef.version.pass.cpp  |  4 ++--
 .../support.limits.general/deque.version.pass.cpp    |  4 ++--
 .../exception.version.pass.cpp                       |  4 ++--
 .../filesystem.version.pass.cpp                      |  4 ++--
 .../forward_list.version.pass.cpp                    |  4 ++--
 .../functional.version.pass.cpp                      |  4 ++--
 .../generate_feature_test_macro_components.py        | 12 +++++++-----
 .../support.limits.general/iomanip.version.pass.cpp  |  4 ++--
 .../support.limits.general/istream.version.pass.cpp  |  4 ++--
 .../support.limits.general/iterator.version.pass.cpp |  4 ++--
 .../support.limits.general/limits.version.pass.cpp   |  4 ++--
 .../support.limits.general/list.version.pass.cpp     |  4 ++--
 .../support.limits.general/locale.version.pass.cpp   |  4 ++--
 .../support.limits.general/map.version.pass.cpp      |  4 ++--
 .../support.limits.general/memory.version.pass.cpp   |  4 ++--
 .../support.limits.general/mutex.version.pass.cpp    |  4 ++--
 .../support.limits.general/new.version.pass.cpp      |  4 ++--
 .../support.limits.general/numeric.version.pass.cpp  |  4 ++--
 .../support.limits.general/optional.version.pass.cpp |  4 ++--
 .../support.limits.general/ostream.version.pass.cpp  |  4 ++--
 .../support.limits.general/regex.version.pass.cpp    |  4 ++--
 .../scoped_allocator.version.pass.cpp                |  4 ++--
 .../support.limits.general/set.version.pass.cpp      |  4 ++--
 .../shared_mutex.version.pass.cpp                    |  4 ++--
 .../support.limits.general/string.version.pass.cpp   |  4 ++--
 .../string_view.version.pass.cpp                     |  4 ++--
 .../support.limits.general/tuple.version.pass.cpp    |  4 ++--
 .../type_traits.version.pass.cpp                     |  4 ++--
 .../unordered_map.version.pass.cpp                   |  4 ++--
 .../unordered_set.version.pass.cpp                   |  4 ++--
 .../support.limits.general/utility.version.pass.cpp  |  4 ++--
 .../support.limits.general/variant.version.pass.cpp  |  4 ++--
 .../support.limits.general/vector.version.pass.cpp   |  4 ++--
 .../support.limits.general/version.version.pass.cpp  |  4 ++--
 43 files changed, 91 insertions(+), 89 deletions(-)

diff --git a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
index 860cbab09..36f82c0b7 100644
--- a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <algorithm>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
index 8e8174323..dbd27c14b 100644
--- a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <any>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
index 75c278581..9d746ece9 100644
--- a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <array>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
index 4ba37542c..835e48d0e 100644
--- a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // UNSUPPORTED: libcpp-has-no-threads
 
diff --git a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
index c3e6a56c6..97d2b9246 100644
--- a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <bit>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
index f777fff88..3605878c5 100644
--- a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <chrono>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
index 02c7c00a5..13d6b9312 100644
--- a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <cmath>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
index e2d8ab88b..c1dff02d2 100644
--- a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <compare>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
index 889aea0fc..170a3da89 100644
--- a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <complex>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
index 55a16288b..f4ebc8e10 100644
--- a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <cstddef>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
index 94cb8290b..a325d6a3a 100644
--- a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <deque>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
index 25a7c3852..97ce6d330 100644
--- a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <exception>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
index 9bd9f08fc..990e5683b 100644
--- a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <filesystem>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
index 41e4b7749..5bf021307 100644
--- a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <forward_list>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
index 4958d4d4c..5ca84c1cc 100644
--- a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <functional>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
index 2f13ed022..c80ebb11e 100755
--- a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
+++ b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
@@ -5,6 +5,7 @@ import tempfile
 
 def get_libcxx_paths():
   script_path = os.path.dirname(os.path.abspath(__file__))
+  script_name = os.path.basename(__file__)
   assert os.path.exists(script_path)
   depth = 5
   src_root = script_path
@@ -14,10 +15,10 @@ def get_libcxx_paths():
   assert os.path.exists(include_path)
   docs_path = os.path.join(src_root, 'docs')
   assert os.path.exists(docs_path)
-  return script_path, src_root, include_path, docs_path
+  return script_path, script_name, src_root, include_path, docs_path
 
 
-script_path, source_root, include_path, docs_path = get_libcxx_paths()
+script_path, script_name, source_root, include_path, docs_path = get_libcxx_paths()
 
 def has_header(h):
   h_path = os.path.join(include_path, h)
@@ -835,8 +836,8 @@ def produce_tests():
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by {script_name}
+// and should not be edited manually.
 {test_tags}
 // <{header}>
 
@@ -866,7 +867,8 @@ def produce_tests():
 #endif // TEST_STD_VER > 17
 
 int main() {{}}
-""".format(header=h,
+""".format(script_name=script_name,
+           header=h,
            test_tags=test_tags,
            synopsis=generate_synopsis(test_list),
            cxx11_tests=generate_std_test(test_list, 'c++11').strip(),
diff --git a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
index f82e5ba04..ef2e05826 100644
--- a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <iomanip>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
index 195ca2d0b..77eec86cf 100644
--- a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <istream>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
index 7113bd3ae..7312c4de7 100644
--- a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <iterator>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
index 91f0d7ced..e63df4ff5 100644
--- a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <limits>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
index 12e683f26..cf087259f 100644
--- a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <list>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
index e77aa7106..352d73637 100644
--- a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <locale>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
index 31ef16061..a98bc28c8 100644
--- a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <map>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
index 4780a1f70..1d8cb9005 100644
--- a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <memory>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
index e572d5796..04edd597b 100644
--- a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <mutex>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
index beddc6010..e2dd9b774 100644
--- a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <new>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
index 39bab221c..83b620765 100644
--- a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <numeric>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
index c7db36f68..4c9fecd21 100644
--- a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <optional>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
index 724171220..1bcf8d55d 100644
--- a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <ostream>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
index 9869e209b..cd07ac068 100644
--- a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <regex>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
index 171fe5e32..4c2f35af9 100644
--- a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <scoped_allocator>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
index 95af65c1f..7a4cabde8 100644
--- a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <set>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
index 98bdf704b..493411ffd 100644
--- a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // UNSUPPORTED: libcpp-has-no-threads
 
diff --git a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
index dd6d09e24..8639c468c 100644
--- a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <string>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
index c8ceb7c7e..44e97f3af 100644
--- a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <string_view>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
index 6e680a774..6466a2f64 100644
--- a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <tuple>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
index 1a8229027..49113a3d0 100644
--- a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <type_traits>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
index 75ce435dd..9aa06e4db 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <unordered_map>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
index c08a8fbd7..3153afd25 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <unordered_set>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
index e24e0a38b..94bdb824a 100644
--- a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <utility>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
index b822eb74f..d4ef3d7e0 100644
--- a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <variant>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
index 6ba328d5c..5cdeca06b 100644
--- a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <vector>
 
diff --git a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
index 27931b447..5fa996967 100644
--- a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: This test was generated by generate_feature_test_macros_tests.py and
-// should not be edited manually.
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
 
 // <version>
 
-- 
GitLab


From a9e8405f23aeb0715e2dde15ddbac102dffea8b4 Mon Sep 17 00:00:00 2001
From: Hans Wennborg <hans@hanshq.net>
Date: Wed, 16 Jan 2019 10:57:02 +0000
Subject: [PATCH 052/137] Bump the trunk version to 9.0.0svn

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351320 91177308-0d34-0410-b5e6-96231b3b80d8
---
 CMakeLists.txt           |  2 +-
 docs/ReleaseNotes.rst    | 29 +++++------------------------
 docs/conf.py             |  4 ++--
 include/__config         |  2 +-
 include/__libcpp_version |  2 +-
 5 files changed, 10 insertions(+), 29 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a57e36fdd..9e27ba41e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   project(libcxx CXX C)
 
   set(PACKAGE_NAME libcxx)
-  set(PACKAGE_VERSION 8.0.0svn)
+  set(PACKAGE_VERSION 9.0.0svn)
   set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
   set(PACKAGE_BUGREPORT "llvm-bugs@lists.llvm.org")
 
diff --git a/docs/ReleaseNotes.rst b/docs/ReleaseNotes.rst
index 20be9f627..29cee4418 100644
--- a/docs/ReleaseNotes.rst
+++ b/docs/ReleaseNotes.rst
@@ -1,5 +1,5 @@
 ========================================
-Libc++ 8.0.0 (In-Progress) Release Notes
+Libc++ 9.0.0 (In-Progress) Release Notes
 ========================================
 
 .. contents::
@@ -10,7 +10,7 @@ Written by the `Libc++ Team <https://libcxx.llvm.org>`_
 
 .. warning::
 
-   These are in-progress notes for the upcoming libc++ 8 release.
+   These are in-progress notes for the upcoming libc++ 9 release.
    Release notes for previous releases can be found on
    `the Download Page <https://releases.llvm.org/download.html>`_.
 
@@ -18,7 +18,7 @@ Introduction
 ============
 
 This document contains the release notes for the libc++ C++ Standard Library,
-part of the LLVM Compiler Infrastructure, release 8.0.0. Here we describe the
+part of the LLVM Compiler Infrastructure, release 9.0.0. Here we describe the
 status of libc++ in some detail, including major improvements from the previous
 release and new feature work. For the general LLVM release notes, see `the LLVM
 documentation <https://llvm.org/docs/ReleaseNotes.html>`_. All LLVM releases may
@@ -32,7 +32,7 @@ main Libc++ web page, this document applies to the *next* release, not
 the current one. To see the release notes for a specific release, please
 see the `releases page <https://llvm.org/releases/>`_.
 
-What's New in Libc++ 8.0.0?
+What's New in Libc++ 9.0.0?
 ===========================
 
 New Features
@@ -40,23 +40,4 @@ New Features
 
 API Changes
 -----------
-- Building libc++ for Mac OSX 10.6 is not supported anymore.
-- Starting with LLVM 8.0.0, users that wish to link together translation units
-  built with different versions of libc++'s headers into the same final linked
-  image MUST define the _LIBCPP_HIDE_FROM_ABI_PER_TU macro to 1 when building
-  those translation units. Not defining _LIBCPP_HIDE_FROM_ABI_PER_TU to 1 and
-  linking translation units built with different versions of libc++'s headers
-  together may lead to ODR violations and ABI issues. On the flipside, code
-  size improvements should be expected for everyone not defining the macro.
-- Starting with LLVM 8.0.0, std::dynarray has been removed from the library.
-  std::dynarray was a feature proposed for C++14 that was pulled from the
-  Standard at the last minute and was never standardized. Since there are no
-  plans to standardize this facility it is being removed.
-- Starting with LLVM 8.0.0, std::bad_array_length has been removed from the
-  library. std::bad_array_length was a feature proposed for C++14 alongside
-  std::dynarray, but it never actually made it into the C++ Standard. There
-  are no plans to standardize this feature at this time. Formally speaking,
-  this removal constitutes an ABI break because the symbols were shipped in
-  the shared library. However, on macOS systems, the feature was not usable
-  because it was hidden behind availability annotations. We do not expect
-  any actual breakage to happen from this change.
+- ...
diff --git a/docs/conf.py b/docs/conf.py
index 50b372cf8..e88b2d337 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -47,9 +47,9 @@ copyright = u'2011-2018, LLVM Project'
 # built documents.
 #
 # The short X.Y version.
-version = '8.0'
+version = '9.0'
 # The full version, including alpha/beta/rc tags.
-release = '8.0'
+release = '9.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
diff --git a/include/__config b/include/__config
index f0bc3483f..f22819b71 100644
--- a/include/__config
+++ b/include/__config
@@ -33,7 +33,7 @@
 #  define _GNUC_VER_NEW 0
 #endif
 
-#define _LIBCPP_VERSION 8000
+#define _LIBCPP_VERSION 9000
 
 #ifndef _LIBCPP_ABI_VERSION
 #  define _LIBCPP_ABI_VERSION 1
diff --git a/include/__libcpp_version b/include/__libcpp_version
index e002b3628..d58c55a31 100644
--- a/include/__libcpp_version
+++ b/include/__libcpp_version
@@ -1 +1 @@
-8000
+9000
-- 
GitLab


From ef4eb5d760a1bd372910c46d721df4dd297a942f Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Thu, 17 Jan 2019 02:59:28 +0000
Subject: [PATCH 053/137] [hurd] Fix unconditional use of PATH_MAX

Patch by Samuel Thibault

The GNU/Hurd system does not define an arbitrary PATH_MAX limitation, the POSIX 2001 realpath
extension can be used instead, and the size of symlinks can be determined.

Reviewed as https://reviews.llvm.org/D54677


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351414 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/filesystem/operations.cpp | 31 +++++++++++++++++++++++++------
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/filesystem/operations.cpp b/src/filesystem/operations.cpp
index b41061888..54a234e5f 100644
--- a/src/filesystem/operations.cpp
+++ b/src/filesystem/operations.cpp
@@ -543,11 +543,19 @@ path __canonical(path const& orig_p, error_code* ec) {
   ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
 
   path p = __do_absolute(orig_p, &cwd, ec);
+#if _POSIX_VERSION >= 200112
+  std::unique_ptr<char, decltype(&::free)>
+    hold(::realpath(p.c_str(), nullptr), &::free);
+  if (hold.get() == nullptr)
+    return err.report(capture_errno());
+  return {hold.get()};
+#else
   char buff[PATH_MAX + 1];
   char* ret;
   if ((ret = ::realpath(p.c_str(), buff)) == nullptr)
     return err.report(capture_errno());
   return {ret};
+#endif
 }
 
 void __copy(const path& from, const path& to, copy_options options,
@@ -1089,16 +1097,27 @@ void __permissions(const path& p, perms prms, perm_options opts,
 path __read_symlink(const path& p, error_code* ec) {
   ErrorHandler<path> err("read_symlink", ec, &p);
 
-  char buff[PATH_MAX + 1];
-  error_code m_ec;
-  ::ssize_t ret;
-  if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
+#ifdef PATH_MAX
+  struct NullDeleter { void operator()(void*) const {} };
+  const size_t size = PATH_MAX + 1;
+  char stack_buff[size];
+  auto buff = std::unique_ptr<char[], NullDeleter>(stack_buff);
+#else
+  StatT sb;
+  if (::lstat(p.c_str(), &sb) == -1) {
     return err.report(capture_errno());
   }
-  _LIBCPP_ASSERT(ret <= PATH_MAX, "TODO");
+  const size_t size = sb.st_size + 1;
+  auto buff = unique_ptr<char[]>(new char[size]);
+#endif
+  ::ssize_t ret;
+  if ((ret = ::readlink(p.c_str(), buff.get(), size)) == -1)
+    return err.report(capture_errno());
   _LIBCPP_ASSERT(ret > 0, "TODO");
+  if (static_cast<size_t>(ret) >= size)
+    return err.report(errc::value_too_large);
   buff[ret] = 0;
-  return {buff};
+  return {buff.get()};
 }
 
 bool __remove(const path& p, error_code* ec) {
-- 
GitLab


From 14072788a3623ce38bc0b8ea3f5a7ee49102b9e6 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sat, 19 Jan 2019 03:27:05 +0000
Subject: [PATCH 054/137] Fix aligned allocation availability XFAILs after
 D56445.

D56445 bumped the minimum Mac OS X version required for aligned
allocation from 10.13 to 10.14. This caused libc++ tests depending
on the old value to break.

This patch updates the XFAILs for those tests to include 10.13.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351625 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../new.delete.array/delete_align_val_t_replace.pass.cpp     | 5 +++--
 .../new.delete/new.delete.array/new_align_val_t.pass.cpp     | 5 +++--
 .../new.delete.array/new_align_val_t_nothrow.pass.cpp        | 5 +++--
 .../new_align_val_t_nothrow_replace.pass.cpp                 | 5 +++--
 .../new.delete.single/delete_align_val_t_replace.pass.cpp    | 5 +++--
 .../new.delete/new.delete.single/new_align_val_t.pass.cpp    | 5 +++--
 .../new.delete.single/new_align_val_t_nothrow.pass.cpp       | 5 +++--
 .../new_align_val_t_nothrow_replace.pass.cpp                 | 5 +++--
 8 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
index 4dd9390c4..297fbf861 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
@@ -17,9 +17,10 @@
 // None of the current GCC compilers support this.
 // UNSUPPORTED: gcc-5, gcc-6
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
index d6194b00a..bb656d8d7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
@@ -15,9 +15,10 @@
 // FIXME change this to XFAIL.
 // UNSUPPORTED: no-aligned-allocation && !gcc
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
index 59878aefd..66a8a5d2c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
@@ -15,9 +15,10 @@
 // FIXME turn this into an XFAIL
 // UNSUPPORTED: no-aligned-allocation && !gcc
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
index fc713dbf8..71b560c4b 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
@@ -10,9 +10,10 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
index 19cabcce1..1ea014aff 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
@@ -16,9 +16,10 @@
 // None of the current GCC compilers support this.
 // UNSUPPORTED: gcc-5, gcc-6
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
index 7cf1aca3b..53a7c8e23 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
@@ -9,9 +9,10 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
index dd2666e00..f165dbf8f 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
@@ -9,9 +9,10 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
index 514a2b8af..6762687a5 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
@@ -10,9 +10,10 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
 // However, AppleClang 10 (and older) don't trigger availability errors.
+// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
-- 
GitLab


From c781cb52814cae89983cba31a65335b1762569ef Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Sat, 19 Jan 2019 06:14:24 +0000
Subject: [PATCH 055/137] Install new LLVM license structure and new developer
 policy.

This installs the new developer policy and moves all of the license
files across all LLVM projects in the monorepo to the new license
structure. The remaining projects will be moved independently.

Note that I've left odd formatting and other idiosyncracies of the
legacy license structure text alone to make the diff easier to read.
Critically, note that we do not in any case *remove* the old license
notice or terms, as that remains necessary until we finish the
relicensing process.

I've updated a few license files that refer to the LLVM license to
instead simply refer generically to whatever license the LLVM project is
under, basically trying to minimize confusion.

This is really the culmination of so many people. Chris led the
community discussions, drafted the policy update and organized the
multi-year string of meeting between lawyers across the community to
figure out the strategy. Numerous lawyers at companies in the community
spent their time figuring out initial answers, and then the Foundation's
lawyer Heather Meeker has done *so* much to help refine and get us ready
here. I could keep going on, but I just want to make sure everyone
realizes what a huge community effort this has been from the begining.

Differential Revision: https://reviews.llvm.org/D56897

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351631 91177308-0d34-0410-b5e6-96231b3b80d8
---
 LICENSE.TXT | 237 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 236 insertions(+), 1 deletion(-)

diff --git a/LICENSE.TXT b/LICENSE.TXT
index 190d9394d..4af93bba1 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -1,5 +1,240 @@
 ==============================================================================
-libc++ License
+The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
+==============================================================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
+
+==============================================================================
+Software from third parties included in the LLVM Project:
+==============================================================================
+The LLVM Project contains third party software which is under different license
+terms. All such code will be identified clearly using at least one of two
+mechanisms:
+1) It will be in a separate directory tree with its own `LICENSE.txt` or
+   `LICENSE` file at the top containing the specific license and restrictions
+   which apply to that software, or
+2) It will contain specific license and restriction terms at the top of every
+   file.
+
+==============================================================================
+Legacy LLVM License (ttps://llvm.org/docs/DeveloperPolicy.html#legacy):
 ==============================================================================
 
 The libc++ library is dual licensed under both the University of Illinois
-- 
GitLab


From 4abbf7dac321f2bfa91e922c9033c86d9137b077 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Sat, 19 Jan 2019 08:50:56 +0000
Subject: [PATCH 056/137] Update the file headers across all of the LLVM
 projects in the monorepo to reflect the new license.

We understand that people may be surprised that we're moving the header
entirely to discuss the new license. We checked this carefully with the
Foundation's lawyer and we believe this is the correct approach.

Essentially, all code in the project is now made available by the LLVM
project under our new license, so you will see that the license headers
include that license only. Some of our contributors have contributed
code under our old license, and accordingly, we have retained a copy of
our old license notice in the top-level files in each project and
repository.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351636 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/__string                               | 7 +++----
 include/__undef_macros                         | 7 +++----
 include/any                                    | 7 +++----
 include/atomic                                 | 7 +++----
 include/cinttypes                              | 7 +++----
 include/cstring                                | 7 +++----
 include/experimental/coroutine                 | 7 +++----
 include/experimental/iterator                  | 7 +++----
 include/experimental/memory_resource           | 7 +++----
 include/inttypes.h                             | 7 +++----
 include/stdint.h                               | 7 +++----
 include/string                                 | 7 +++----
 include/string.h                               | 7 +++----
 include/string_view                            | 7 +++----
 include/tuple                                  | 7 +++----
 test/support/constexpr_char_traits.hpp         | 7 +++----
 utils/docker/build_docker_image.sh             | 7 +++----
 utils/docker/debian9/Dockerfile                | 7 +++----
 utils/docker/scripts/build_gcc.sh              | 7 +++----
 utils/docker/scripts/build_install_llvm.sh     | 7 +++----
 utils/docker/scripts/checkout_git.sh           | 7 +++----
 utils/docker/scripts/install_clang_packages.sh | 7 +++----
 22 files changed, 66 insertions(+), 88 deletions(-)

diff --git a/include/__string b/include/__string
index 1ddeec714..a88b976be 100644
--- a/include/__string
+++ b/include/__string
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- __string ----------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__undef_macros b/include/__undef_macros
index 60ab1dbfb..4923ee6b4 100644
--- a/include/__undef_macros
+++ b/include/__undef_macros
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ __undef_macros ------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/any b/include/any
index 781eee786..f3518c34f 100644
--- a/include/any
+++ b/include/any
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ any -----------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/atomic b/include/atomic
index d37e7b4b0..60057f1eb 100644
--- a/include/atomic
+++ b/include/atomic
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- atomic -----------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cinttypes b/include/cinttypes
index 3f61b0634..55af85cc3 100644
--- a/include/cinttypes
+++ b/include/cinttypes
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cinttypes --------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cstring b/include/cstring
index d550695ca..8bc96a023 100644
--- a/include/cstring
+++ b/include/cstring
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cstring ----------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/coroutine b/include/experimental/coroutine
index 7cb39b81b..13e326250 100644
--- a/include/experimental/coroutine
+++ b/include/experimental/coroutine
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- coroutine -----------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/iterator b/include/experimental/iterator
index ea672e966..6a6e51d82 100644
--- a/include/experimental/iterator
+++ b/include/experimental/iterator
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- iterator -------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/memory_resource b/include/experimental/memory_resource
index 83781d462..f999fb9be 100644
--- a/include/experimental/memory_resource
+++ b/include/experimental/memory_resource
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ memory_resource -----------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/inttypes.h b/include/inttypes.h
index 058f54b51..0f1d4f455 100644
--- a/include/inttypes.h
+++ b/include/inttypes.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- inttypes.h -------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/stdint.h b/include/stdint.h
index 468f6cd97..c89229845 100644
--- a/include/stdint.h
+++ b/include/stdint.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- stdint.h --------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/string b/include/string
index fb838d1e5..e6d161423 100644
--- a/include/string
+++ b/include/string
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- string -----------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/string.h b/include/string.h
index a1ce56cbc..e09251d06 100644
--- a/include/string.h
+++ b/include/string.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- string.h ---------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/string_view b/include/string_view
index 7d783122f..79565c245 100644
--- a/include/string_view
+++ b/include/string_view
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ string_view ---------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/tuple b/include/tuple
index 4cc69030b..15cbf2689 100644
--- a/include/tuple
+++ b/include/tuple
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- tuple ------------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/constexpr_char_traits.hpp b/test/support/constexpr_char_traits.hpp
index 7508567ca..df43d8f7c 100644
--- a/test/support/constexpr_char_traits.hpp
+++ b/test/support/constexpr_char_traits.hpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------- constexpr_char_traits ---------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/utils/docker/build_docker_image.sh b/utils/docker/build_docker_image.sh
index 0d2d6d313..cc6a18870 100755
--- a/utils/docker/build_docker_image.sh
+++ b/utils/docker/build_docker_image.sh
@@ -1,10 +1,9 @@
 #!/bin/bash
 #===- libcxx/utils/docker/build_docker_image.sh ----------------------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===//
 set -e
diff --git a/utils/docker/debian9/Dockerfile b/utils/docker/debian9/Dockerfile
index 8dc43f401..3f291d04c 100644
--- a/utils/docker/debian9/Dockerfile
+++ b/utils/docker/debian9/Dockerfile
@@ -1,9 +1,8 @@
 #===- libcxx/utils/docker/debian9/Dockerfile -------------------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===//
 
diff --git a/utils/docker/scripts/build_gcc.sh b/utils/docker/scripts/build_gcc.sh
index 85feb16ac..3627a9ae9 100755
--- a/utils/docker/scripts/build_gcc.sh
+++ b/utils/docker/scripts/build_gcc.sh
@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 #===- libcxx/utils/docker/scripts/build-gcc.sh ----------------------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===-----------------------------------------------------------------------===//
 
diff --git a/utils/docker/scripts/build_install_llvm.sh b/utils/docker/scripts/build_install_llvm.sh
index 6f19a96a1..d37e52d32 100755
--- a/utils/docker/scripts/build_install_llvm.sh
+++ b/utils/docker/scripts/build_install_llvm.sh
@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 #===- llvm/utils/docker/scripts/build_install_llvm.sh ---------------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===-----------------------------------------------------------------------===//
 
diff --git a/utils/docker/scripts/checkout_git.sh b/utils/docker/scripts/checkout_git.sh
index 222700229..2c5563b43 100755
--- a/utils/docker/scripts/checkout_git.sh
+++ b/utils/docker/scripts/checkout_git.sh
@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 #===- llvm/utils/docker/scripts/checkout.sh ---------------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===-----------------------------------------------------------------------===//
 
diff --git a/utils/docker/scripts/install_clang_packages.sh b/utils/docker/scripts/install_clang_packages.sh
index fabee0e81..4a46c90a4 100755
--- a/utils/docker/scripts/install_clang_packages.sh
+++ b/utils/docker/scripts/install_clang_packages.sh
@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 #===- libcxx/utils/docker/scripts/install_clang_package.sh -----------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===-----------------------------------------------------------------------===//
 
-- 
GitLab


From 4685928b62544d8cab9c9504f5f66d9a99a62c00 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sat, 19 Jan 2019 09:07:04 +0000
Subject: [PATCH 057/137] Fix all the bots.

The buildbot start scripts hardcode the version string.
Bump it from 8 to 9.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351638 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/docker/scripts/run_buildbot.sh | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/utils/docker/scripts/run_buildbot.sh b/utils/docker/scripts/run_buildbot.sh
index 45f5a1cf6..96e832dd4 100755
--- a/utils/docker/scripts/run_buildbot.sh
+++ b/utils/docker/scripts/run_buildbot.sh
@@ -15,9 +15,9 @@ apt-get upgrade -y
 # FIXME(EricWF): Remove this hack. It's only in place to temporarily fix linking libclang_rt from the
 # debian packages.
 # WARNING: If you're not a buildbot, DO NOT RUN!
-apt-get install lld-8
+apt-get install lld-9
 rm /usr/bin/ld
-ln -s /usr/bin/lld-8 /usr/bin/ld
+ln -s /usr/bin/lld-9 /usr/bin/ld
 
 systemctl set-property buildslave.service TasksMax=100000
 
@@ -59,4 +59,4 @@ grep "slave is ready" $BOT_DIR/twistd.log || shutdown now
 # Gracefully restart before that happen.
 sleep 72000
 while pkill -SIGHUP buildslave; do sleep 5; done;
-shutdown now
\ No newline at end of file
+shutdown now
-- 
GitLab


From 7c3769df62c0b3820130aa868397a80a042e0232 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Sat, 19 Jan 2019 10:56:40 +0000
Subject: [PATCH 058/137] Update more file headers across all of the LLVM
 projects in the monorepo to reflect the new license. These used slightly
 different spellings that defeated my regular expressions.

We understand that people may be surprised that we're moving the header
entirely to discuss the new license. We checked this carefully with the
Foundation's lawyer and we believe this is the correct approach.

Essentially, all code in the project is now made available by the LLVM
project under our new license, so you will see that the license headers
include that license only. Some of our contributors have contributed
code under our old license, and accordingly, we have retained a copy of
our old license notice in the top-level files in each project and
repository.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351648 91177308-0d34-0410-b5e6-96231b3b80d8
---
 benchmarks/CartesianBenchmarks.hpp                         | 7 +++----
 benchmarks/function.bench.cpp                              | 7 +++----
 benchmarks/ordered_set.bench.cpp                           | 7 +++----
 benchmarks/util_smartptr.bench.cpp                         | 7 +++----
 fuzzing/fuzz_test.cpp                                      | 7 +++----
 fuzzing/fuzzing.cpp                                        | 7 +++----
 fuzzing/fuzzing.h                                          | 7 +++----
 include/__bit_reference                                    | 7 +++----
 include/__bsd_locale_defaults.h                            | 7 +++----
 include/__bsd_locale_fallbacks.h                           | 7 +++----
 include/__config                                           | 7 +++----
 include/__config_site.in                                   | 7 +++----
 include/__debug                                            | 7 +++----
 include/__errc                                             | 7 +++----
 include/__functional_03                                    | 7 +++----
 include/__functional_base                                  | 7 +++----
 include/__functional_base_03                               | 7 +++----
 include/__hash_table                                       | 7 +++----
 include/__locale                                           | 7 +++----
 include/__mutex_base                                       | 7 +++----
 include/__node_handle                                      | 7 +++----
 include/__nullptr                                          | 7 +++----
 include/__sso_allocator                                    | 7 +++----
 include/__std_stream                                       | 7 +++----
 include/__threading_support                                | 7 +++----
 include/__tree                                             | 7 +++----
 include/__tuple                                            | 7 +++----
 include/algorithm                                          | 7 +++----
 include/array                                              | 7 +++----
 include/bit                                                | 7 +++----
 include/bitset                                             | 7 +++----
 include/cassert                                            | 7 +++----
 include/ccomplex                                           | 7 +++----
 include/cctype                                             | 7 +++----
 include/cerrno                                             | 7 +++----
 include/cfenv                                              | 7 +++----
 include/cfloat                                             | 7 +++----
 include/charconv                                           | 7 +++----
 include/chrono                                             | 7 +++----
 include/ciso646                                            | 7 +++----
 include/climits                                            | 7 +++----
 include/clocale                                            | 7 +++----
 include/cmath                                              | 7 +++----
 include/codecvt                                            | 7 +++----
 include/compare                                            | 7 +++----
 include/complex                                            | 7 +++----
 include/complex.h                                          | 7 +++----
 include/condition_variable                                 | 7 +++----
 include/csetjmp                                            | 7 +++----
 include/csignal                                            | 7 +++----
 include/cstdarg                                            | 7 +++----
 include/cstdbool                                           | 7 +++----
 include/cstddef                                            | 7 +++----
 include/cstdint                                            | 7 +++----
 include/cstdio                                             | 7 +++----
 include/cstdlib                                            | 7 +++----
 include/ctgmath                                            | 7 +++----
 include/ctime                                              | 7 +++----
 include/ctype.h                                            | 7 +++----
 include/cwchar                                             | 7 +++----
 include/cwctype                                            | 7 +++----
 include/deque                                              | 7 +++----
 include/errno.h                                            | 7 +++----
 include/exception                                          | 7 +++----
 include/experimental/__config                              | 7 +++----
 include/experimental/__memory                              | 7 +++----
 include/experimental/algorithm                             | 7 +++----
 include/experimental/any                                   | 7 +++----
 include/experimental/chrono                                | 7 +++----
 include/experimental/deque                                 | 7 +++----
 include/experimental/filesystem                            | 7 +++----
 include/experimental/forward_list                          | 7 +++----
 include/experimental/functional                            | 7 +++----
 include/experimental/list                                  | 7 +++----
 include/experimental/map                                   | 7 +++----
 include/experimental/numeric                               | 7 +++----
 include/experimental/optional                              | 7 +++----
 include/experimental/propagate_const                       | 7 +++----
 include/experimental/ratio                                 | 7 +++----
 include/experimental/regex                                 | 7 +++----
 include/experimental/set                                   | 7 +++----
 include/experimental/simd                                  | 7 +++----
 include/experimental/string                                | 7 +++----
 include/experimental/string_view                           | 7 +++----
 include/experimental/system_error                          | 7 +++----
 include/experimental/tuple                                 | 7 +++----
 include/experimental/type_traits                           | 7 +++----
 include/experimental/unordered_map                         | 7 +++----
 include/experimental/unordered_set                         | 7 +++----
 include/experimental/utility                               | 7 +++----
 include/experimental/vector                                | 7 +++----
 include/ext/__hash                                         | 7 +++----
 include/ext/hash_map                                       | 7 +++----
 include/ext/hash_set                                       | 7 +++----
 include/filesystem                                         | 7 +++----
 include/float.h                                            | 7 +++----
 include/forward_list                                       | 7 +++----
 include/fstream                                            | 7 +++----
 include/functional                                         | 7 +++----
 include/future                                             | 7 +++----
 include/initializer_list                                   | 7 +++----
 include/iomanip                                            | 7 +++----
 include/ios                                                | 7 +++----
 include/iosfwd                                             | 7 +++----
 include/iostream                                           | 7 +++----
 include/istream                                            | 7 +++----
 include/iterator                                           | 7 +++----
 include/limits                                             | 7 +++----
 include/limits.h                                           | 7 +++----
 include/list                                               | 7 +++----
 include/locale                                             | 7 +++----
 include/locale.h                                           | 7 +++----
 include/map                                                | 7 +++----
 include/math.h                                             | 7 +++----
 include/memory                                             | 7 +++----
 include/mutex                                              | 7 +++----
 include/new                                                | 7 +++----
 include/numeric                                            | 7 +++----
 include/optional                                           | 7 +++----
 include/ostream                                            | 7 +++----
 include/queue                                              | 7 +++----
 include/random                                             | 7 +++----
 include/ratio                                              | 7 +++----
 include/regex                                              | 7 +++----
 include/scoped_allocator                                   | 7 +++----
 include/set                                                | 7 +++----
 include/setjmp.h                                           | 7 +++----
 include/shared_mutex                                       | 7 +++----
 include/span                                               | 7 +++----
 include/sstream                                            | 7 +++----
 include/stack                                              | 7 +++----
 include/stdbool.h                                          | 7 +++----
 include/stddef.h                                           | 7 +++----
 include/stdexcept                                          | 7 +++----
 include/stdio.h                                            | 7 +++----
 include/stdlib.h                                           | 7 +++----
 include/streambuf                                          | 7 +++----
 include/strstream                                          | 7 +++----
 include/support/android/locale_bionic.h                    | 7 +++----
 include/support/fuchsia/xlocale.h                          | 7 +++----
 include/support/ibm/limits.h                               | 7 +++----
 include/support/ibm/locale_mgmt_aix.h                      | 7 +++----
 include/support/ibm/support.h                              | 7 +++----
 include/support/ibm/xlocale.h                              | 7 +++----
 include/support/musl/xlocale.h                             | 7 +++----
 include/support/newlib/xlocale.h                           | 7 +++----
 include/support/solaris/floatingpoint.h                    | 7 +++----
 include/support/solaris/wchar.h                            | 7 +++----
 include/support/solaris/xlocale.h                          | 7 +++----
 include/support/win32/limits_msvc_win32.h                  | 7 +++----
 include/support/win32/locale_win32.h                       | 7 +++----
 include/support/xlocale/__nop_locale_mgmt.h                | 7 +++----
 include/support/xlocale/__posix_l_fallback.h               | 7 +++----
 include/support/xlocale/__strtonum_fallback.h              | 7 +++----
 include/system_error                                       | 7 +++----
 include/tgmath.h                                           | 7 +++----
 include/thread                                             | 7 +++----
 include/type_traits                                        | 7 +++----
 include/typeindex                                          | 7 +++----
 include/typeinfo                                           | 7 +++----
 include/unordered_map                                      | 7 +++----
 include/unordered_set                                      | 7 +++----
 include/utility                                            | 7 +++----
 include/valarray                                           | 7 +++----
 include/variant                                            | 7 +++----
 include/vector                                             | 7 +++----
 include/version                                            | 7 +++----
 include/wchar.h                                            | 7 +++----
 include/wctype.h                                           | 7 +++----
 src/algorithm.cpp                                          | 7 +++----
 src/any.cpp                                                | 7 +++----
 src/bind.cpp                                               | 7 +++----
 src/charconv.cpp                                           | 7 +++----
 src/chrono.cpp                                             | 7 +++----
 src/condition_variable.cpp                                 | 7 +++----
 src/debug.cpp                                              | 7 +++----
 src/exception.cpp                                          | 7 +++----
 src/experimental/memory_resource.cpp                       | 7 +++----
 src/filesystem/directory_iterator.cpp                      | 7 +++----
 src/filesystem/filesystem_common.h                         | 7 +++----
 src/filesystem/int128_builtins.cpp                         | 7 +++----
 src/filesystem/operations.cpp                              | 7 +++----
 src/functional.cpp                                         | 7 +++----
 src/future.cpp                                             | 7 +++----
 src/hash.cpp                                               | 7 +++----
 src/include/apple_availability.h                           | 7 +++----
 src/include/atomic_support.h                               | 7 +++----
 src/include/config_elast.h                                 | 7 +++----
 src/include/refstring.h                                    | 7 +++----
 src/ios.cpp                                                | 7 +++----
 src/iostream.cpp                                           | 7 +++----
 src/locale.cpp                                             | 7 +++----
 src/memory.cpp                                             | 7 +++----
 src/mutex.cpp                                              | 7 +++----
 src/new.cpp                                                | 7 +++----
 src/optional.cpp                                           | 7 +++----
 src/random.cpp                                             | 7 +++----
 src/regex.cpp                                              | 7 +++----
 src/shared_mutex.cpp                                       | 7 +++----
 src/stdexcept.cpp                                          | 7 +++----
 src/string.cpp                                             | 7 +++----
 src/strstream.cpp                                          | 7 +++----
 src/support/runtime/exception_fallback.ipp                 | 7 +++----
 src/support/runtime/exception_glibcxx.ipp                  | 7 +++----
 src/support/runtime/exception_libcxxabi.ipp                | 7 +++----
 src/support/runtime/exception_libcxxrt.ipp                 | 7 +++----
 src/support/runtime/exception_msvc.ipp                     | 7 +++----
 src/support/runtime/exception_pointer_cxxabi.ipp           | 7 +++----
 src/support/runtime/exception_pointer_glibcxx.ipp          | 7 +++----
 src/support/runtime/exception_pointer_msvc.ipp             | 7 +++----
 src/support/runtime/exception_pointer_unimplemented.ipp    | 7 +++----
 src/support/runtime/new_handler_fallback.ipp               | 7 +++----
 src/support/solaris/xlocale.cpp                            | 7 +++----
 src/support/win32/locale_win32.cpp                         | 7 +++----
 src/support/win32/support.cpp                              | 7 +++----
 src/support/win32/thread_win32.cpp                         | 7 +++----
 src/system_error.cpp                                       | 7 +++----
 src/thread.cpp                                             | 7 +++----
 src/typeinfo.cpp                                           | 7 +++----
 src/utility.cpp                                            | 7 +++----
 src/valarray.cpp                                           | 7 +++----
 src/variant.cpp                                            | 7 +++----
 src/vector.cpp                                             | 7 +++----
 .../alg.random.shuffle/random_shuffle.cxx1z.pass.cpp       | 7 +++----
 .../random_shuffle.depr_in_cxx14.fail.cpp                  | 7 +++----
 test/libcxx/algorithms/debug_less.pass.cpp                 | 7 +++----
 test/libcxx/algorithms/half_positive.pass.cpp              | 7 +++----
 test/libcxx/algorithms/version.pass.cpp                    | 7 +++----
 test/libcxx/atomics/atomics.align/align.pass.sh.cpp        | 7 +++----
 test/libcxx/atomics/atomics.flag/init_bool.pass.cpp        | 7 +++----
 test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp | 7 +++----
 test/libcxx/atomics/libcpp-has-no-threads.fail.cpp         | 7 +++----
 test/libcxx/atomics/libcpp-has-no-threads.pass.cpp         | 7 +++----
 test/libcxx/atomics/version.pass.cpp                       | 7 +++----
 test/libcxx/containers/associative/map/version.pass.cpp    | 7 +++----
 .../containers/associative/non_const_comparator.fail.cpp   | 7 +++----
 test/libcxx/containers/associative/set/version.pass.cpp    | 7 +++----
 .../associative/tree_balance_after_insert.pass.cpp         | 7 +++----
 .../containers/associative/tree_key_value_traits.pass.cpp  | 7 +++----
 .../containers/associative/tree_left_rotate.pass.cpp       | 7 +++----
 test/libcxx/containers/associative/tree_remove.pass.cpp    | 7 +++----
 .../containers/associative/tree_right_rotate.pass.cpp      | 7 +++----
 test/libcxx/containers/associative/undef_min_max.pass.cpp  | 7 +++----
 .../containers/container.adaptors/queue/version.pass.cpp   | 7 +++----
 .../containers/container.adaptors/stack/version.pass.cpp   | 7 +++----
 test/libcxx/containers/gnu_cxx/hash_map.pass.cpp           | 7 +++----
 test/libcxx/containers/gnu_cxx/hash_set.pass.cpp           | 7 +++----
 .../containers/sequences/array/array.zero/db_back.pass.cpp | 7 +++----
 .../sequences/array/array.zero/db_front.pass.cpp           | 7 +++----
 .../sequences/array/array.zero/db_indexing.pass.cpp        | 7 +++----
 test/libcxx/containers/sequences/array/version.pass.cpp    | 7 +++----
 test/libcxx/containers/sequences/deque/incomplete.pass.cpp | 7 +++----
 .../containers/sequences/deque/pop_back_empty.pass.cpp     | 7 +++----
 test/libcxx/containers/sequences/deque/version.pass.cpp    | 7 +++----
 .../containers/sequences/forwardlist/version.pass.cpp      | 7 +++----
 .../containers/sequences/list/list.cons/db_copy.pass.cpp   | 7 +++----
 .../containers/sequences/list/list.cons/db_move.pass.cpp   | 7 +++----
 .../sequences/list/list.modifiers/emplace_db1.pass.cpp     | 7 +++----
 .../sequences/list/list.modifiers/erase_iter_db1.pass.cpp  | 7 +++----
 .../sequences/list/list.modifiers/erase_iter_db2.pass.cpp  | 7 +++----
 .../list/list.modifiers/erase_iter_iter_db1.pass.cpp       | 7 +++----
 .../list/list.modifiers/erase_iter_iter_db2.pass.cpp       | 7 +++----
 .../list/list.modifiers/erase_iter_iter_db3.pass.cpp       | 7 +++----
 .../list/list.modifiers/erase_iter_iter_db4.pass.cpp       | 7 +++----
 .../list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp | 7 +++----
 .../list/list.modifiers/insert_iter_rvalue_db1.pass.cpp    | 7 +++----
 .../list.modifiers/insert_iter_size_value_db1.pass.cpp     | 7 +++----
 .../list/list.modifiers/insert_iter_value_db1.pass.cpp     | 7 +++----
 .../sequences/list/list.modifiers/pop_back_db1.pass.cpp    | 7 +++----
 .../sequences/list/list.ops/db_splice_pos_list.pass.cpp    | 7 +++----
 .../list/list.ops/db_splice_pos_list_iter.pass.cpp         | 7 +++----
 .../list/list.ops/db_splice_pos_list_iter_iter.pass.cpp    | 7 +++----
 test/libcxx/containers/sequences/list/version.pass.cpp     | 7 +++----
 test/libcxx/containers/sequences/vector/asan.pass.cpp      | 7 +++----
 .../libcxx/containers/sequences/vector/asan_throw.pass.cpp | 7 +++----
 .../containers/sequences/vector/const_value_type.pass.cpp  | 7 +++----
 test/libcxx/containers/sequences/vector/db_back.pass.cpp   | 7 +++----
 test/libcxx/containers/sequences/vector/db_cback.pass.cpp  | 7 +++----
 test/libcxx/containers/sequences/vector/db_cfront.pass.cpp | 7 +++----
 test/libcxx/containers/sequences/vector/db_cindex.pass.cpp | 7 +++----
 test/libcxx/containers/sequences/vector/db_front.pass.cpp  | 7 +++----
 test/libcxx/containers/sequences/vector/db_index.pass.cpp  | 7 +++----
 .../containers/sequences/vector/db_iterators_2.pass.cpp    | 7 +++----
 .../containers/sequences/vector/db_iterators_3.pass.cpp    | 7 +++----
 .../containers/sequences/vector/db_iterators_4.pass.cpp    | 7 +++----
 .../containers/sequences/vector/db_iterators_5.pass.cpp    | 7 +++----
 .../containers/sequences/vector/db_iterators_6.pass.cpp    | 7 +++----
 .../containers/sequences/vector/db_iterators_7.pass.cpp    | 7 +++----
 .../containers/sequences/vector/db_iterators_8.pass.cpp    | 7 +++----
 .../containers/sequences/vector/pop_back_empty.pass.cpp    | 7 +++----
 .../vector/vector.cons/construct_iter_iter.pass.cpp        | 7 +++----
 .../vector/vector.cons/construct_iter_iter_alloc.pass.cpp  | 7 +++----
 test/libcxx/containers/sequences/vector/version.pass.cpp   | 7 +++----
 test/libcxx/containers/unord/key_value_traits.pass.cpp     | 7 +++----
 test/libcxx/containers/unord/next_pow2.pass.cpp            | 7 +++----
 test/libcxx/containers/unord/next_prime.pass.cpp           | 7 +++----
 test/libcxx/containers/unord/non_const_comparator.fail.cpp | 7 +++----
 .../containers/unord/unord.map/db_iterators_7.pass.cpp     | 7 +++----
 .../containers/unord/unord.map/db_iterators_8.pass.cpp     | 7 +++----
 .../unord/unord.map/db_local_iterators_7.pass.cpp          | 7 +++----
 .../unord/unord.map/db_local_iterators_8.pass.cpp          | 7 +++----
 test/libcxx/containers/unord/unord.map/version.pass.cpp    | 7 +++----
 .../unord/unord.set/missing_hash_specialization.fail.cpp   | 7 +++----
 test/libcxx/containers/unord/unord.set/version.pass.cpp    | 7 +++----
 .../containers/db_associative_container_tests.pass.cpp     | 7 +++----
 .../containers/db_sequence_container_iterators.pass.cpp    | 7 +++----
 test/libcxx/debug/containers/db_string.pass.cpp            | 7 +++----
 .../debug/containers/db_unord_container_tests.pass.cpp     | 7 +++----
 test/libcxx/debug/debug_abort.pass.cpp                     | 7 +++----
 test/libcxx/debug/debug_throw.pass.cpp                     | 7 +++----
 test/libcxx/debug/debug_throw_register.pass.cpp            | 7 +++----
 .../depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp    | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp | 7 +++----
 test/libcxx/depr/depr.c.headers/ciso646.pass.cpp           | 7 +++----
 test/libcxx/depr/depr.c.headers/complex.h.pass.cpp         | 7 +++----
 test/libcxx/depr/depr.c.headers/extern_c.pass.cpp          | 7 +++----
 test/libcxx/depr/depr.c.headers/locale_h.pass.cpp          | 7 +++----
 test/libcxx/depr/depr.c.headers/math_h.sh.cpp              | 7 +++----
 test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp          | 7 +++----
 .../depr.function.objects/adaptors.depr_in_cxx11.fail.cpp  | 7 +++----
 .../depr.function.objects/depr.adaptors.cxx1z.pass.cpp     | 7 +++----
 test/libcxx/depr/depr.str.strstreams/version.pass.cpp      | 7 +++----
 test/libcxx/depr/enable_removed_cpp17_features.pass.cpp    | 7 +++----
 .../depr/exception.unexpected/get_unexpected.pass.cpp      | 7 +++----
 .../depr/exception.unexpected/set_unexpected.pass.cpp      | 7 +++----
 test/libcxx/depr/exception.unexpected/unexpected.pass.cpp  | 7 +++----
 .../unexpected_disabled_cpp17.fail.cpp                     | 7 +++----
 .../libcxx/diagnostics/assertions/version_cassert.pass.cpp | 7 +++----
 test/libcxx/diagnostics/enable_nodiscard.fail.cpp          | 7 +++----
 .../enable_nodiscard_disable_after_cxx17.fail.cpp          | 7 +++----
 .../enable_nodiscard_disable_nodiscard_ext.fail.cpp        | 7 +++----
 test/libcxx/diagnostics/errno/version_cerrno.pass.cpp      | 7 +++----
 test/libcxx/diagnostics/nodiscard.pass.cpp                 | 7 +++----
 test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp      | 7 +++----
 test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp      | 7 +++----
 test/libcxx/diagnostics/nodiscard_extensions.fail.cpp      | 7 +++----
 test/libcxx/diagnostics/nodiscard_extensions.pass.cpp      | 7 +++----
 test/libcxx/diagnostics/std.exceptions/version.pass.cpp    | 7 +++----
 test/libcxx/diagnostics/syserr/version.pass.cpp            | 7 +++----
 test/libcxx/double_include.sh.cpp                          | 7 +++----
 .../algorithms/header.algorithm.synop/includes.pass.cpp    | 7 +++----
 test/libcxx/experimental/algorithms/version.pass.cpp       | 7 +++----
 .../diagnostics/syserr/use_header_warning.fail.cpp         | 7 +++----
 .../experimental/diagnostics/syserr/version.pass.cpp       | 7 +++----
 test/libcxx/experimental/filesystem/version.pass.cpp       | 7 +++----
 .../support.coroutines/dialect_support.sh.cpp              | 7 +++----
 .../language.support/support.coroutines/version.sh.cpp     | 7 +++----
 .../construct_piecewise_pair.pass.cpp                      | 7 +++----
 .../db_deallocate.pass.cpp                                 | 7 +++----
 .../memory.resource.adaptor.mem/db_deallocate.pass.cpp     | 7 +++----
 .../header_deque_libcpp_version.pass.cpp                   | 7 +++----
 .../header_forward_list_libcpp_version.pass.cpp            | 7 +++----
 .../header_list_libcpp_version.pass.cpp                    | 7 +++----
 .../header_map_libcpp_version.pass.cpp                     | 7 +++----
 .../header_regex_libcpp_version.pass.cpp                   | 7 +++----
 .../header_set_libcpp_version.pass.cpp                     | 7 +++----
 .../header_string_libcpp_version.pass.cpp                  | 7 +++----
 .../header_unordered_map_libcpp_version.pass.cpp           | 7 +++----
 .../header_unordered_set_libcpp_version.pass.cpp           | 7 +++----
 .../header_vector_libcpp_version.pass.cpp                  | 7 +++----
 .../global_memory_resource_lifetime.pass.cpp               | 7 +++----
 .../new_delete_resource_lifetime.pass.cpp                  | 7 +++----
 .../memory/memory.resource.synop/version.pass.cpp          | 7 +++----
 .../numerics/numeric.ops/use_header_warning.fail.cpp       | 7 +++----
 .../experimental/numerics/numeric.ops/version.pass.cpp     | 7 +++----
 .../strings/string.view/use_header_warning.fail.cpp        | 7 +++----
 .../experimental/strings/string.view/version.pass.cpp      | 7 +++----
 .../experimental/utilities/any/use_header_warning.fail.cpp | 7 +++----
 test/libcxx/experimental/utilities/any/version.pass.cpp    | 7 +++----
 test/libcxx/experimental/utilities/meta/version.pass.cpp   | 7 +++----
 .../utilities/optional/use_header_warning.fail.cpp         | 7 +++----
 .../experimental/utilities/optional/version.pass.cpp       | 7 +++----
 .../utilities/ratio/use_header_warning.fail.cpp            | 7 +++----
 test/libcxx/experimental/utilities/ratio/version.pass.cpp  | 7 +++----
 .../utilities/time/use_header_warning.fail.cpp             | 7 +++----
 test/libcxx/experimental/utilities/time/version.pass.cpp   | 7 +++----
 .../utilities/tuple/use_header_warning.fail.cpp            | 7 +++----
 test/libcxx/experimental/utilities/tuple/version.pass.cpp  | 7 +++----
 .../libcxx/experimental/utilities/utility/version.pass.cpp | 7 +++----
 test/libcxx/extensions/hash/specializations.fail.cpp       | 7 +++----
 test/libcxx/extensions/hash/specializations.pass.cpp       | 7 +++----
 test/libcxx/extensions/hash_map/const_iterator.fail.cpp    | 7 +++----
 test/libcxx/extensions/nothing_to_do.pass.cpp              | 7 +++----
 test/libcxx/fuzzing/nth_element.cpp                        | 7 +++----
 test/libcxx/fuzzing/partial_sort.cpp                       | 7 +++----
 test/libcxx/fuzzing/partial_sort_copy.cpp                  | 7 +++----
 test/libcxx/fuzzing/partition.cpp                          | 7 +++----
 test/libcxx/fuzzing/partition_copy.cpp                     | 7 +++----
 test/libcxx/fuzzing/regex_ECMAScript.cpp                   | 7 +++----
 test/libcxx/fuzzing/regex_POSIX.cpp                        | 7 +++----
 test/libcxx/fuzzing/regex_awk.cpp                          | 7 +++----
 test/libcxx/fuzzing/regex_egrep.cpp                        | 7 +++----
 test/libcxx/fuzzing/regex_extended.cpp                     | 7 +++----
 test/libcxx/fuzzing/regex_grep.cpp                         | 7 +++----
 test/libcxx/fuzzing/sort.cpp                               | 7 +++----
 test/libcxx/fuzzing/stable_partition.cpp                   | 7 +++----
 test/libcxx/fuzzing/stable_sort.cpp                        | 7 +++----
 test/libcxx/fuzzing/unique.cpp                             | 7 +++----
 test/libcxx/fuzzing/unique_copy.cpp                        | 7 +++----
 test/libcxx/include_as_c.sh.cpp                            | 7 +++----
 .../c.files/no.global.filesystem.namespace/fopen.fail.cpp  | 7 +++----
 .../c.files/no.global.filesystem.namespace/rename.fail.cpp | 7 +++----
 .../file.streams/c.files/version_ccstdio.pass.cpp          | 7 +++----
 .../file.streams/c.files/version_cinttypes.pass.cpp        | 7 +++----
 .../file.streams/fstreams/filebuf/traits_mismatch.fail.cpp | 7 +++----
 .../file.streams/fstreams/fstream.close.pass.cpp           | 7 +++----
 .../fstreams/fstream.cons/wchar_pointer.pass.cpp           | 7 +++----
 .../fstreams/fstream.members/open_wchar_pointer.pass.cpp   | 7 +++----
 .../fstreams/ifstream.cons/wchar_pointer.pass.cpp          | 7 +++----
 .../fstreams/ifstream.members/open_wchar_pointer.pass.cpp  | 7 +++----
 .../fstreams/ofstream.cons/wchar_pointer.pass.cpp          | 7 +++----
 .../fstreams/ofstream.members/open_wchar_pointer.pass.cpp  | 7 +++----
 .../file.streams/fstreams/traits_mismatch.fail.cpp         | 7 +++----
 .../input.output/file.streams/fstreams/version.pass.cpp    | 7 +++----
 .../directory_entry.mods/last_write_time.sh.cpp            | 7 +++----
 .../filesystems/class.path/path.itr/iterator_db.pass.cpp   | 7 +++----
 .../path.itr/reverse_iterator_produces_diagnostic.fail.cpp | 7 +++----
 .../filesystems/class.path/path.req/is_pathable.pass.cpp   | 7 +++----
 .../input.output/filesystems/convert_file_time.sh.cpp      | 7 +++----
 test/libcxx/input.output/filesystems/version.pass.cpp      | 7 +++----
 .../iostream.format/input.streams/traits_mismatch.fail.cpp | 7 +++----
 .../iostream.format/input.streams/version.pass.cpp         | 7 +++----
 .../output.streams/traits_mismatch.fail.cpp                | 7 +++----
 .../iostream.format/output.streams/version.pass.cpp        | 7 +++----
 .../iostream.format/std.manip/version.pass.cpp             | 7 +++----
 test/libcxx/input.output/iostream.forward/version.pass.cpp | 7 +++----
 test/libcxx/input.output/iostream.objects/version.pass.cpp | 7 +++----
 test/libcxx/input.output/iostreams.base/version.pass.cpp   | 7 +++----
 test/libcxx/input.output/stream.buffers/version.pass.cpp   | 7 +++----
 .../input.output/string.streams/traits_mismatch.fail.cpp   | 7 +++----
 test/libcxx/input.output/string.streams/version.pass.cpp   | 7 +++----
 test/libcxx/iterators/failed.pass.cpp                      | 7 +++----
 test/libcxx/iterators/trivial_iterators.pass.cpp           | 7 +++----
 test/libcxx/iterators/version.pass.cpp                     | 7 +++----
 test/libcxx/language.support/cmp/version.pass.cpp          | 7 +++----
 test/libcxx/language.support/cstdint/version.pass.cpp      | 7 +++----
 test/libcxx/language.support/cxa_deleted_virtual.pass.cpp  | 7 +++----
 test/libcxx/language.support/has_c11_features.pass.cpp     | 7 +++----
 .../support.dynamic/libcpp_deallocate.sh.cpp               | 7 +++----
 .../support.dynamic/new_faligned_allocation.sh.cpp         | 7 +++----
 .../language.support/support.dynamic/version.pass.cpp      | 7 +++----
 .../language.support/support.exception/version.pass.cpp    | 7 +++----
 .../language.support/support.initlist/version.pass.cpp     | 7 +++----
 .../support.limits/c.limits/version_cfloat.pass.cpp        | 7 +++----
 .../support.limits/c.limits/version_climits.pass.cpp       | 7 +++----
 .../support.limits/limits/version.pass.cpp                 | 7 +++----
 .../language.support/support.limits/version.pass.cpp       | 7 +++----
 test/libcxx/language.support/support.rtti/version.pass.cpp | 7 +++----
 .../support.runtime/version_csetjmp.pass.cpp               | 7 +++----
 .../support.runtime/version_csignal.pass.cpp               | 7 +++----
 .../support.runtime/version_cstdarg.pass.cpp               | 7 +++----
 .../support.runtime/version_cstdbool.pass.cpp              | 7 +++----
 .../support.runtime/version_cstdlib.pass.cpp               | 7 +++----
 .../support.runtime/version_ctime.pass.cpp                 | 7 +++----
 .../libcxx/language.support/support.types/version.pass.cpp | 7 +++----
 test/libcxx/libcpp_alignof.pass.cpp                        | 7 +++----
 test/libcxx/libcpp_version.pass.cpp                        | 7 +++----
 test/libcxx/localization/c.locales/version.pass.cpp        | 7 +++----
 .../localization/locale.categories/__scan_keyword.pass.cpp | 7 +++----
 test/libcxx/localization/locale.stdcvt/version.pass.cpp    | 7 +++----
 .../conversions/conversions.string/ctor_move.pass.cpp      | 7 +++----
 .../locale/locale.types/locale.facet/facet.pass.cpp        | 7 +++----
 .../locales/locale/locale.types/locale.id/id.pass.cpp      | 7 +++----
 test/libcxx/localization/version.pass.cpp                  | 7 +++----
 test/libcxx/memory/aligned_allocation_macro.pass.cpp       | 7 +++----
 test/libcxx/memory/is_allocator.pass.cpp                   | 7 +++----
 test/libcxx/min_max_macros.sh.cpp                          | 7 +++----
 test/libcxx/modules/cinttypes_exports.sh.cpp               | 7 +++----
 test/libcxx/modules/clocale_exports.sh.cpp                 | 7 +++----
 test/libcxx/modules/cstdint_exports.sh.cpp                 | 7 +++----
 test/libcxx/modules/inttypes_h_exports.sh.cpp              | 7 +++----
 test/libcxx/modules/stdint_h_exports.sh.cpp                | 7 +++----
 test/libcxx/numerics/c.math/constexpr-fns.pass.cpp         | 7 +++----
 test/libcxx/numerics/c.math/ctgmath.pass.cpp               | 7 +++----
 .../numerics/c.math/fdelayed-template-parsing.sh.cpp       | 7 +++----
 test/libcxx/numerics/c.math/tgmath_h.pass.cpp              | 7 +++----
 test/libcxx/numerics/c.math/version_cmath.pass.cpp         | 7 +++----
 test/libcxx/numerics/cfenv/version.pass.cpp                | 7 +++----
 test/libcxx/numerics/complex.number/__sqr.pass.cpp         | 7 +++----
 .../numerics/complex.number/ccmplx/ccomplex.pass.cpp       | 7 +++----
 test/libcxx/numerics/complex.number/version.pass.cpp       | 7 +++----
 test/libcxx/numerics/numarray/version.pass.cpp             | 7 +++----
 test/libcxx/numerics/numeric.ops/version.pass.cpp          | 7 +++----
 test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp   | 7 +++----
 test/libcxx/selftest/not_test.sh.cpp                       | 7 +++----
 test/libcxx/selftest/test.arc.fail.mm                      | 7 +++----
 test/libcxx/selftest/test.arc.pass.mm                      | 7 +++----
 test/libcxx/selftest/test.fail.cpp                         | 7 +++----
 test/libcxx/selftest/test.fail.mm                          | 7 +++----
 test/libcxx/selftest/test.pass.cpp                         | 7 +++----
 test/libcxx/selftest/test.pass.mm                          | 7 +++----
 test/libcxx/selftest/test.sh.cpp                           | 7 +++----
 test/libcxx/selftest/test_macros.pass.cpp                  | 7 +++----
 .../string.modifiers/clear_and_shrink_db1.pass.cpp         | 7 +++----
 .../basic.string/string.modifiers/erase_iter_db1.pass.cpp  | 7 +++----
 .../basic.string/string.modifiers/erase_iter_db2.pass.cpp  | 7 +++----
 .../string.modifiers/erase_iter_iter_db1.pass.cpp          | 7 +++----
 .../string.modifiers/erase_iter_iter_db2.pass.cpp          | 7 +++----
 .../string.modifiers/erase_iter_iter_db3.pass.cpp          | 7 +++----
 .../string.modifiers/erase_iter_iter_db4.pass.cpp          | 7 +++----
 .../string.modifiers/erase_pop_back_db1.pass.cpp           | 7 +++----
 .../string.modifiers/insert_iter_char_db1.pass.cpp         | 7 +++----
 .../string.modifiers/insert_iter_size_char_db1.pass.cpp    | 7 +++----
 .../string.modifiers/resize_default_initialized.pass.cpp   | 7 +++----
 test/libcxx/strings/c.strings/version_cctype.pass.cpp      | 7 +++----
 test/libcxx/strings/c.strings/version_cstring.pass.cpp     | 7 +++----
 test/libcxx/strings/c.strings/version_cuchar.pass.cpp      | 7 +++----
 test/libcxx/strings/c.strings/version_cwchar.pass.cpp      | 7 +++----
 test/libcxx/strings/c.strings/version_cwctype.pass.cpp     | 7 +++----
 test/libcxx/strings/iterators.exceptions.pass.cpp          | 7 +++----
 test/libcxx/strings/iterators.noexcept.pass.cpp            | 7 +++----
 test/libcxx/strings/version.pass.cpp                       | 7 +++----
 .../thread/futures/futures.promise/set_exception.pass.cpp  | 7 +++----
 .../futures.promise/set_exception_at_thread_exit.pass.cpp  | 7 +++----
 test/libcxx/thread/futures/futures.task/types.pass.cpp     | 7 +++----
 test/libcxx/thread/futures/version.pass.cpp                | 7 +++----
 .../PR30202_notify_from_pthread_created_thread.pass.cpp    | 7 +++----
 .../thread.condition.condvar/native_handle.pass.cpp        | 7 +++----
 test/libcxx/thread/thread.condition/version.pass.cpp       | 7 +++----
 .../thread.mutex.class/native_handle.pass.cpp              | 7 +++----
 .../thread.mutex.recursive/native_handle.pass.cpp          | 7 +++----
 .../thread_safety_annotations_not_enabled.pass.cpp         | 7 +++----
 .../thread/thread.mutex/thread_safety_lock_guard.pass.cpp  | 7 +++----
 .../thread/thread.mutex/thread_safety_lock_unlock.pass.cpp | 7 +++----
 .../thread.mutex/thread_safety_missing_unlock.fail.cpp     | 7 +++----
 .../thread_safety_requires_capability.pass.cpp             | 7 +++----
 test/libcxx/thread/thread.mutex/version.pass.cpp           | 7 +++----
 .../thread.thread.member/native_handle.pass.cpp            | 7 +++----
 .../thread.threads/thread.thread.class/types.pass.cpp      | 7 +++----
 .../thread.threads/thread.thread.this/sleep_for.pass.cpp   | 7 +++----
 test/libcxx/thread/thread.threads/version.pass.cpp         | 7 +++----
 test/libcxx/type_traits/convert_to_integral.pass.cpp       | 7 +++----
 test/libcxx/type_traits/lazy_metafunctions.pass.cpp        | 7 +++----
 test/libcxx/utilities/any/size_and_alignment.pass.cpp      | 7 +++----
 test/libcxx/utilities/any/small_type.pass.cpp              | 7 +++----
 test/libcxx/utilities/any/version.pass.cpp                 | 7 +++----
 .../function.objects/func.require/bullet_1_2_3.pass.cpp    | 7 +++----
 .../function.objects/func.require/bullet_4_5_6.pass.cpp    | 7 +++----
 .../function.objects/func.require/bullet_7.pass.cpp        | 7 +++----
 .../function.objects/func.require/invoke.pass.cpp          | 7 +++----
 .../function.objects/func.require/invoke_helpers.h         | 7 +++----
 .../utilities/function.objects/refwrap/binary.pass.cpp     | 7 +++----
 .../utilities/function.objects/refwrap/unary.pass.cpp      | 7 +++----
 ...r2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp | 7 +++----
 test/libcxx/utilities/function.objects/version.pass.cpp    | 7 +++----
 .../util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp  | 7 +++----
 .../get_pointer_safety_new_abi.pass.cpp                    | 7 +++----
 .../utilities/memory/util.smartptr/race_condition.pass.cpp | 7 +++----
 test/libcxx/utilities/memory/version.pass.cpp              | 7 +++----
 test/libcxx/utilities/meta/is_referenceable.pass.cpp       | 7 +++----
 .../meta.unary.prop/__has_operator_addressof.pass.cpp      | 7 +++----
 .../meta.unary.prop/missing_is_aggregate_trait.fail.cpp    | 7 +++----
 test/libcxx/utilities/meta/version.pass.cpp                | 7 +++----
 .../optional.object/optional.object.assign/copy.pass.cpp   | 7 +++----
 .../optional.object/optional.object.assign/move.pass.cpp   | 7 +++----
 .../optional.object/optional.object.ctor/copy.pass.cpp     | 7 +++----
 .../optional.object/optional.object.ctor/move.pass.cpp     | 7 +++----
 .../optional/optional.object/triviality.abi.pass.cpp       | 7 +++----
 test/libcxx/utilities/optional/version.pass.cpp            | 7 +++----
 test/libcxx/utilities/ratio/version.pass.cpp               | 7 +++----
 test/libcxx/utilities/template.bitset/includes.pass.cpp    | 7 +++----
 test/libcxx/utilities/template.bitset/version.pass.cpp     | 7 +++----
 .../time/date.time/asctime.thread-unsafe.fail.cpp          | 7 +++----
 .../utilities/time/date.time/ctime.thread-unsafe.fail.cpp  | 7 +++----
 .../utilities/time/date.time/gmtime.thread-unsafe.fail.cpp | 7 +++----
 .../time/date.time/localtime.thread-unsafe.fail.cpp        | 7 +++----
 test/libcxx/utilities/time/version.pass.cpp                | 7 +++----
 .../utilities/tuple/tuple.tuple/empty_member.pass.cpp      | 7 +++----
 .../PR20855_tuple_ref_binding_diagnostics.fail.cpp         | 7 +++----
 ...disable_reduced_arity_initialization_extension.pass.cpp | 7 +++----
 .../enable_reduced_arity_initialization_extension.pass.cpp | 7 +++----
 test/libcxx/utilities/tuple/version.pass.cpp               | 7 +++----
 test/libcxx/utilities/type.index/version.pass.cpp          | 7 +++----
 test/libcxx/utilities/utility/__is_inplace_index.pass.cpp  | 7 +++----
 test/libcxx/utilities/utility/__is_inplace_type.pass.cpp   | 7 +++----
 .../libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp | 7 +++----
 .../utility/pairs/pairs.pair/assign_tuple_like.pass.cpp    | 7 +++----
 .../pairs/pairs.pair/const_first_const_second.pass.cpp     | 7 +++----
 .../utility/pairs/pairs.pair/const_pair_U_V.pass.cpp       | 7 +++----
 .../utilities/utility/pairs/pairs.pair/default.pass.cpp    | 7 +++----
 .../pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp    | 7 +++----
 .../utility/pairs/pairs.pair/pair.tuple_element.fail.cpp   | 7 +++----
 .../utilities/utility/pairs/pairs.pair/piecewise.pass.cpp  | 7 +++----
 .../utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp          | 7 +++----
 .../pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp        | 7 +++----
 test/libcxx/utilities/utility/version.pass.cpp             | 7 +++----
 .../variant.helper/variant_alternative.fail.cpp            | 7 +++----
 .../variant/variant.variant/variant_size.pass.cpp          | 7 +++----
 test/libcxx/utilities/variant/version.pass.cpp             | 7 +++----
 test/nothing_to_do.pass.cpp                                | 7 +++----
 .../std/algorithms/alg.c.library/tested_elsewhere.pass.cpp | 7 +++----
 .../alg.modifying.operations/alg.copy/copy.pass.cpp        | 7 +++----
 .../alg.copy/copy_backward.pass.cpp                        | 7 +++----
 .../alg.modifying.operations/alg.copy/copy_if.pass.cpp     | 7 +++----
 .../alg.modifying.operations/alg.copy/copy_n.pass.cpp      | 7 +++----
 .../alg.modifying.operations/alg.fill/fill.pass.cpp        | 7 +++----
 .../alg.modifying.operations/alg.fill/fill_n.pass.cpp      | 7 +++----
 .../alg.generate/generate.pass.cpp                         | 7 +++----
 .../alg.generate/generate_n.pass.cpp                       | 7 +++----
 .../alg.modifying.operations/alg.move/move.pass.cpp        | 7 +++----
 .../alg.move/move_backward.pass.cpp                        | 7 +++----
 .../alg.partitions/is_partitioned.pass.cpp                 | 7 +++----
 .../alg.partitions/partition.pass.cpp                      | 7 +++----
 .../alg.partitions/partition_copy.pass.cpp                 | 7 +++----
 .../alg.partitions/partition_point.pass.cpp                | 7 +++----
 .../alg.partitions/stable_partition.pass.cpp               | 7 +++----
 .../alg.random.sample/sample.fail.cpp                      | 7 +++----
 .../alg.random.sample/sample.pass.cpp                      | 7 +++----
 .../alg.random.sample/sample.stable.pass.cpp               | 7 +++----
 .../alg.random.shuffle/random_shuffle.pass.cpp             | 7 +++----
 .../alg.random.shuffle/random_shuffle_rand.pass.cpp        | 7 +++----
 .../alg.random.shuffle/random_shuffle_urng.pass.cpp        | 7 +++----
 .../alg.modifying.operations/alg.remove/remove.pass.cpp    | 7 +++----
 .../alg.remove/remove_copy.pass.cpp                        | 7 +++----
 .../alg.remove/remove_copy_if.pass.cpp                     | 7 +++----
 .../alg.modifying.operations/alg.remove/remove_if.pass.cpp | 7 +++----
 .../alg.modifying.operations/alg.replace/replace.pass.cpp  | 7 +++----
 .../alg.replace/replace_copy.pass.cpp                      | 7 +++----
 .../alg.replace/replace_copy_if.pass.cpp                   | 7 +++----
 .../alg.replace/replace_if.pass.cpp                        | 7 +++----
 .../alg.modifying.operations/alg.reverse/reverse.pass.cpp  | 7 +++----
 .../alg.reverse/reverse_copy.pass.cpp                      | 7 +++----
 .../alg.modifying.operations/alg.rotate/rotate.pass.cpp    | 7 +++----
 .../alg.rotate/rotate_copy.pass.cpp                        | 7 +++----
 .../alg.modifying.operations/alg.swap/iter_swap.pass.cpp   | 7 +++----
 .../alg.modifying.operations/alg.swap/swap_ranges.pass.cpp | 7 +++----
 .../alg.transform/binary_transform.pass.cpp                | 7 +++----
 .../alg.transform/unary_transform.pass.cpp                 | 7 +++----
 .../alg.modifying.operations/alg.unique/unique.pass.cpp    | 7 +++----
 .../alg.unique/unique_copy.pass.cpp                        | 7 +++----
 .../alg.unique/unique_copy_pred.pass.cpp                   | 7 +++----
 .../alg.unique/unique_pred.pass.cpp                        | 7 +++----
 .../alg.modifying.operations/nothing_to_do.pass.cpp        | 7 +++----
 .../alg.adjacent.find/adjacent_find.pass.cpp               | 7 +++----
 .../alg.adjacent.find/adjacent_find_pred.pass.cpp          | 7 +++----
 .../algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp | 7 +++----
 .../algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp | 7 +++----
 .../algorithms/alg.nonmodifying/alg.count/count.pass.cpp   | 7 +++----
 .../alg.nonmodifying/alg.count/count_if.pass.cpp           | 7 +++----
 .../algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp   | 7 +++----
 .../alg.nonmodifying/alg.equal/equal_pred.pass.cpp         | 7 +++----
 .../alg.nonmodifying/alg.find.end/find_end.pass.cpp        | 7 +++----
 .../alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp   | 7 +++----
 .../alg.find.first.of/find_first_of.pass.cpp               | 7 +++----
 .../alg.find.first.of/find_first_of_pred.pass.cpp          | 7 +++----
 .../std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp | 7 +++----
 .../algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp  | 7 +++----
 .../alg.nonmodifying/alg.find/find_if_not.pass.cpp         | 7 +++----
 .../alg.nonmodifying/alg.foreach/for_each_n.pass.cpp       | 7 +++----
 .../algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp  | 7 +++----
 .../alg.is_permutation/is_permutation.pass.cpp             | 7 +++----
 .../alg.is_permutation/is_permutation_pred.pass.cpp        | 7 +++----
 .../alg.nonmodifying/alg.none_of/none_of.pass.cpp          | 7 +++----
 .../algorithms/alg.nonmodifying/alg.search/search.pass.cpp | 7 +++----
 .../alg.nonmodifying/alg.search/search_n.pass.cpp          | 7 +++----
 .../alg.nonmodifying/alg.search/search_n_pred.pass.cpp     | 7 +++----
 .../alg.nonmodifying/alg.search/search_pred.pass.cpp       | 7 +++----
 .../algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp | 7 +++----
 .../alg.nonmodifying/mismatch/mismatch_pred.pass.cpp       | 7 +++----
 .../std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp | 7 +++----
 .../alg.binary.search/binary.search/binary_search.pass.cpp | 7 +++----
 .../binary.search/binary_search_comp.pass.cpp              | 7 +++----
 .../alg.binary.search/equal.range/equal_range.pass.cpp     | 7 +++----
 .../equal.range/equal_range_comp.pass.cpp                  | 7 +++----
 .../alg.binary.search/lower.bound/lower_bound.pass.cpp     | 7 +++----
 .../lower.bound/lower_bound_comp.pass.cpp                  | 7 +++----
 .../alg.sorting/alg.binary.search/nothing_to_do.pass.cpp   | 7 +++----
 .../alg.binary.search/upper.bound/upper_bound.pass.cpp     | 7 +++----
 .../upper.bound/upper_bound_comp.pass.cpp                  | 7 +++----
 .../algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp   | 7 +++----
 test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp   | 7 +++----
 .../alg.heap.operations/is.heap/is_heap.pass.cpp           | 7 +++----
 .../alg.heap.operations/is.heap/is_heap_comp.pass.cpp      | 7 +++----
 .../alg.heap.operations/is.heap/is_heap_until.pass.cpp     | 7 +++----
 .../is.heap/is_heap_until_comp.pass.cpp                    | 7 +++----
 .../alg.heap.operations/make.heap/make_heap.pass.cpp       | 7 +++----
 .../alg.heap.operations/make.heap/make_heap_comp.pass.cpp  | 7 +++----
 .../alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp | 7 +++----
 .../alg.heap.operations/pop.heap/pop_heap.pass.cpp         | 7 +++----
 .../alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp    | 7 +++----
 .../alg.heap.operations/push.heap/push_heap.pass.cpp       | 7 +++----
 .../alg.heap.operations/push.heap/push_heap_comp.pass.cpp  | 7 +++----
 .../alg.heap.operations/sort.heap/sort_heap.pass.cpp       | 7 +++----
 .../alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp  | 7 +++----
 .../alg.lex.comparison/lexicographical_compare.pass.cpp    | 7 +++----
 .../lexicographical_compare_comp.pass.cpp                  | 7 +++----
 .../alg.sorting/alg.merge/inplace_merge.pass.cpp           | 7 +++----
 .../alg.sorting/alg.merge/inplace_merge_comp.pass.cpp      | 7 +++----
 test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp   | 7 +++----
 .../algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp   | 7 +++----
 test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp   | 7 +++----
 .../algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp   | 7 +++----
 .../alg.sorting/alg.min.max/max_element.pass.cpp           | 7 +++----
 .../alg.sorting/alg.min.max/max_element_comp.pass.cpp      | 7 +++----
 .../alg.sorting/alg.min.max/max_init_list.pass.cpp         | 7 +++----
 .../alg.sorting/alg.min.max/max_init_list_comp.pass.cpp    | 7 +++----
 test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp   | 7 +++----
 .../algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp   | 7 +++----
 .../alg.sorting/alg.min.max/min_element.pass.cpp           | 7 +++----
 .../alg.sorting/alg.min.max/min_element_comp.pass.cpp      | 7 +++----
 .../alg.sorting/alg.min.max/min_init_list.pass.cpp         | 7 +++----
 .../alg.sorting/alg.min.max/min_init_list_comp.pass.cpp    | 7 +++----
 .../std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp | 7 +++----
 .../alg.sorting/alg.min.max/minmax_comp.pass.cpp           | 7 +++----
 .../alg.sorting/alg.min.max/minmax_element.pass.cpp        | 7 +++----
 .../alg.sorting/alg.min.max/minmax_element_comp.pass.cpp   | 7 +++----
 .../alg.sorting/alg.min.max/minmax_init_list.pass.cpp      | 7 +++----
 .../alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp | 7 +++----
 .../alg.min.max/requires_forward_iterator.fail.cpp         | 7 +++----
 .../alg.sorting/alg.nth.element/nth_element.pass.cpp       | 7 +++----
 .../alg.sorting/alg.nth.element/nth_element_comp.pass.cpp  | 7 +++----
 .../alg.permutation.generators/next_permutation.pass.cpp   | 7 +++----
 .../next_permutation_comp.pass.cpp                         | 7 +++----
 .../alg.permutation.generators/prev_permutation.pass.cpp   | 7 +++----
 .../prev_permutation_comp.pass.cpp                         | 7 +++----
 .../alg.set.operations/includes/includes.pass.cpp          | 7 +++----
 .../alg.set.operations/includes/includes_comp.pass.cpp     | 7 +++----
 .../alg.sorting/alg.set.operations/nothing_to_do.pass.cpp  | 7 +++----
 .../set.difference/set_difference.pass.cpp                 | 7 +++----
 .../set.difference/set_difference_comp.pass.cpp            | 7 +++----
 .../set.intersection/set_intersection.pass.cpp             | 7 +++----
 .../set.intersection/set_intersection_comp.pass.cpp        | 7 +++----
 .../set_symmetric_difference.pass.cpp                      | 7 +++----
 .../set_symmetric_difference_comp.pass.cpp                 | 7 +++----
 .../alg.set.operations/set.union/set_union.pass.cpp        | 7 +++----
 .../alg.set.operations/set.union/set_union_comp.pass.cpp   | 7 +++----
 .../alg.set.operations/set.union/set_union_move.pass.cpp   | 7 +++----
 .../alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp      | 7 +++----
 .../alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp | 7 +++----
 .../alg.sort/is.sorted/is_sorted_until.pass.cpp            | 7 +++----
 .../alg.sort/is.sorted/is_sorted_until_comp.pass.cpp       | 7 +++----
 .../algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp | 7 +++----
 .../alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp  | 7 +++----
 .../partial.sort.copy/partial_sort_copy_comp.pass.cpp      | 7 +++----
 .../alg.sort/partial.sort/partial_sort.pass.cpp            | 7 +++----
 .../alg.sort/partial.sort/partial_sort_comp.pass.cpp       | 7 +++----
 .../std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp | 7 +++----
 .../alg.sorting/alg.sort/sort/sort_comp.pass.cpp           | 7 +++----
 .../alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp  | 7 +++----
 .../alg.sort/stable.sort/stable_sort_comp.pass.cpp         | 7 +++----
 test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp     | 7 +++----
 .../algorithms/algorithms.general/nothing_to_do.pass.cpp   | 7 +++----
 .../atomics/atomics.fences/atomic_signal_fence.pass.cpp    | 7 +++----
 .../atomics/atomics.fences/atomic_thread_fence.pass.cpp    | 7 +++----
 test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp   | 7 +++----
 .../atomics.flag/atomic_flag_clear_explicit.pass.cpp       | 7 +++----
 .../atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp | 7 +++----
 .../atomic_flag_test_and_set_explicit.pass.cpp             | 7 +++----
 test/std/atomics/atomics.flag/clear.pass.cpp               | 7 +++----
 test/std/atomics/atomics.flag/copy_assign.fail.cpp         | 7 +++----
 test/std/atomics/atomics.flag/copy_ctor.fail.cpp           | 7 +++----
 .../std/atomics/atomics.flag/copy_volatile_assign.fail.cpp | 7 +++----
 test/std/atomics/atomics.flag/default.pass.cpp             | 7 +++----
 test/std/atomics/atomics.flag/init.pass.cpp                | 7 +++----
 test/std/atomics/atomics.flag/test_and_set.pass.cpp        | 7 +++----
 test/std/atomics/atomics.general/nothing_to_do.pass.cpp    | 7 +++----
 .../atomics/atomics.general/replace_failure_order.pass.cpp | 7 +++----
 .../std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp | 7 +++----
 test/std/atomics/atomics.lockfree/lockfree.pass.cpp        | 7 +++----
 test/std/atomics/atomics.order/kill_dependency.pass.cpp    | 7 +++----
 test/std/atomics/atomics.order/memory_order.pass.cpp       | 7 +++----
 test/std/atomics/atomics.syn/nothing_to_do.pass.cpp        | 7 +++----
 test/std/atomics/atomics.types.generic/address.pass.cpp    | 7 +++----
 test/std/atomics/atomics.types.generic/bool.pass.cpp       | 7 +++----
 .../atomics.types.generic/cstdint_typedefs.pass.cpp        | 7 +++----
 test/std/atomics/atomics.types.generic/integral.pass.cpp   | 7 +++----
 .../atomics.types.generic/integral_typedefs.pass.cpp       | 7 +++----
 .../atomics.types.generic/trivially_copyable.fail.cpp      | 7 +++----
 .../atomics.types.generic/trivially_copyable.pass.cpp      | 7 +++----
 .../atomics.types.operations.arith/nothing_to_do.pass.cpp  | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../atomic_compare_exchange_strong.pass.cpp                | 7 +++----
 .../atomic_compare_exchange_strong_explicit.pass.cpp       | 7 +++----
 .../atomic_compare_exchange_weak.pass.cpp                  | 7 +++----
 .../atomic_compare_exchange_weak_explicit.pass.cpp         | 7 +++----
 .../atomics.types.operations.req/atomic_exchange.pass.cpp  | 7 +++----
 .../atomic_exchange_explicit.pass.cpp                      | 7 +++----
 .../atomics.types.operations.req/atomic_fetch_add.pass.cpp | 7 +++----
 .../atomic_fetch_add_explicit.pass.cpp                     | 7 +++----
 .../atomics.types.operations.req/atomic_fetch_and.pass.cpp | 7 +++----
 .../atomic_fetch_and_explicit.pass.cpp                     | 7 +++----
 .../atomics.types.operations.req/atomic_fetch_or.pass.cpp  | 7 +++----
 .../atomic_fetch_or_explicit.pass.cpp                      | 7 +++----
 .../atomics.types.operations.req/atomic_fetch_sub.pass.cpp | 7 +++----
 .../atomic_fetch_sub_explicit.pass.cpp                     | 7 +++----
 .../atomics.types.operations.req/atomic_fetch_xor.pass.cpp | 7 +++----
 .../atomic_fetch_xor_explicit.pass.cpp                     | 7 +++----
 .../atomics.types.operations.req/atomic_helpers.h          | 7 +++----
 .../atomics.types.operations.req/atomic_init.pass.cpp      | 7 +++----
 .../atomic_is_lock_free.pass.cpp                           | 7 +++----
 .../atomics.types.operations.req/atomic_load.pass.cpp      | 7 +++----
 .../atomic_load_explicit.pass.cpp                          | 7 +++----
 .../atomics.types.operations.req/atomic_store.pass.cpp     | 7 +++----
 .../atomic_store_explicit.pass.cpp                         | 7 +++----
 .../atomics.types.operations.req/atomic_var_init.pass.cpp  | 7 +++----
 .../atomics.types.operations.req/ctor.pass.cpp             | 7 +++----
 .../atomics.types.operations.templ/nothing_to_do.pass.cpp  | 7 +++----
 .../atomics.types.operations/nothing_to_do.pass.cpp        | 7 +++----
 test/std/containers/Copyable.h                             | 7 +++----
 test/std/containers/Emplaceable.h                          | 7 +++----
 test/std/containers/NotConstructible.h                     | 7 +++----
 test/std/containers/associative/iterator_types.pass.cpp    | 7 +++----
 .../map/PR28469_undefined_behavior_segfault.sh.cpp         | 7 +++----
 .../containers/associative/map/allocator_mismatch.fail.cpp | 7 +++----
 test/std/containers/associative/map/compare.pass.cpp       | 7 +++----
 .../containers/associative/map/incomplete_type.pass.cpp    | 7 +++----
 test/std/containers/associative/map/map.access/at.pass.cpp | 7 +++----
 .../containers/associative/map/map.access/empty.fail.cpp   | 7 +++----
 .../containers/associative/map/map.access/empty.pass.cpp   | 7 +++----
 .../associative/map/map.access/index_key.pass.cpp          | 7 +++----
 .../associative/map/map.access/index_rv_key.pass.cpp       | 7 +++----
 .../associative/map/map.access/index_tuple.pass.cpp        | 7 +++----
 .../associative/map/map.access/iterator.pass.cpp           | 7 +++----
 .../associative/map/map.access/max_size.pass.cpp           | 7 +++----
 .../containers/associative/map/map.access/size.pass.cpp    | 7 +++----
 .../std/containers/associative/map/map.cons/alloc.pass.cpp | 7 +++----
 .../map/map.cons/assign_initializer_list.pass.cpp          | 7 +++----
 .../containers/associative/map/map.cons/compare.pass.cpp   | 7 +++----
 .../associative/map/map.cons/compare_alloc.pass.cpp        | 7 +++----
 .../map/map.cons/compare_copy_constructible.fail.cpp       | 7 +++----
 test/std/containers/associative/map/map.cons/copy.pass.cpp | 7 +++----
 .../associative/map/map.cons/copy_alloc.pass.cpp           | 7 +++----
 .../associative/map/map.cons/copy_assign.pass.cpp          | 7 +++----
 .../containers/associative/map/map.cons/default.pass.cpp   | 7 +++----
 .../associative/map/map.cons/default_noexcept.pass.cpp     | 7 +++----
 .../associative/map/map.cons/default_recursive.pass.cpp    | 7 +++----
 .../associative/map/map.cons/dtor_noexcept.pass.cpp        | 7 +++----
 .../associative/map/map.cons/initializer_list.pass.cpp     | 7 +++----
 .../map/map.cons/initializer_list_compare.pass.cpp         | 7 +++----
 .../map/map.cons/initializer_list_compare_alloc.pass.cpp   | 7 +++----
 .../containers/associative/map/map.cons/iter_iter.pass.cpp | 7 +++----
 .../associative/map/map.cons/iter_iter_comp.pass.cpp       | 7 +++----
 .../associative/map/map.cons/iter_iter_comp_alloc.pass.cpp | 7 +++----
 test/std/containers/associative/map/map.cons/move.pass.cpp | 7 +++----
 .../associative/map/map.cons/move_alloc.pass.cpp           | 7 +++----
 .../associative/map/map.cons/move_assign.pass.cpp          | 7 +++----
 .../associative/map/map.cons/move_assign_noexcept.pass.cpp | 7 +++----
 .../associative/map/map.cons/move_noexcept.pass.cpp        | 7 +++----
 .../associative/map/map.erasure/erase_if.pass.cpp          | 7 +++----
 .../associative/map/map.modifiers/clear.pass.cpp           | 7 +++----
 .../associative/map/map.modifiers/emplace.pass.cpp         | 7 +++----
 .../associative/map/map.modifiers/emplace_hint.pass.cpp    | 7 +++----
 .../associative/map/map.modifiers/erase_iter.pass.cpp      | 7 +++----
 .../associative/map/map.modifiers/erase_iter_iter.pass.cpp | 7 +++----
 .../associative/map/map.modifiers/erase_key.pass.cpp       | 7 +++----
 .../map/map.modifiers/extract_iterator.pass.cpp            | 7 +++----
 .../associative/map/map.modifiers/extract_key.pass.cpp     | 7 +++----
 .../insert_and_emplace_allocator_requirements.pass.cpp     | 7 +++----
 .../associative/map/map.modifiers/insert_cv.pass.cpp       | 7 +++----
 .../map/map.modifiers/insert_initializer_list.pass.cpp     | 7 +++----
 .../associative/map/map.modifiers/insert_iter_cv.pass.cpp  | 7 +++----
 .../map/map.modifiers/insert_iter_iter.pass.cpp            | 7 +++----
 .../associative/map/map.modifiers/insert_iter_rv.pass.cpp  | 7 +++----
 .../map/map.modifiers/insert_node_type.pass.cpp            | 7 +++----
 .../map/map.modifiers/insert_node_type_hint.pass.cpp       | 7 +++----
 .../map/map.modifiers/insert_or_assign.pass.cpp            | 7 +++----
 .../associative/map/map.modifiers/insert_rv.pass.cpp       | 7 +++----
 .../associative/map/map.modifiers/merge.pass.cpp           | 7 +++----
 .../associative/map/map.modifiers/try.emplace.pass.cpp     | 7 +++----
 test/std/containers/associative/map/map.ops/count.pass.cpp | 7 +++----
 .../std/containers/associative/map/map.ops/count0.pass.cpp | 7 +++----
 .../std/containers/associative/map/map.ops/count1.fail.cpp | 7 +++----
 .../std/containers/associative/map/map.ops/count2.fail.cpp | 7 +++----
 .../std/containers/associative/map/map.ops/count3.fail.cpp | 7 +++----
 .../associative/map/map.ops/count_transparent.pass.cpp     | 7 +++----
 .../associative/map/map.ops/equal_range.pass.cpp           | 7 +++----
 .../associative/map/map.ops/equal_range0.pass.cpp          | 7 +++----
 .../associative/map/map.ops/equal_range1.fail.cpp          | 7 +++----
 .../associative/map/map.ops/equal_range2.fail.cpp          | 7 +++----
 .../associative/map/map.ops/equal_range3.fail.cpp          | 7 +++----
 .../map/map.ops/equal_range_transparent.pass.cpp           | 7 +++----
 test/std/containers/associative/map/map.ops/find.pass.cpp  | 7 +++----
 test/std/containers/associative/map/map.ops/find0.pass.cpp | 7 +++----
 test/std/containers/associative/map/map.ops/find1.fail.cpp | 7 +++----
 test/std/containers/associative/map/map.ops/find2.fail.cpp | 7 +++----
 test/std/containers/associative/map/map.ops/find3.fail.cpp | 7 +++----
 .../associative/map/map.ops/lower_bound.pass.cpp           | 7 +++----
 .../associative/map/map.ops/lower_bound0.pass.cpp          | 7 +++----
 .../associative/map/map.ops/lower_bound1.fail.cpp          | 7 +++----
 .../associative/map/map.ops/lower_bound2.fail.cpp          | 7 +++----
 .../associative/map/map.ops/lower_bound3.fail.cpp          | 7 +++----
 .../associative/map/map.ops/upper_bound.pass.cpp           | 7 +++----
 .../associative/map/map.ops/upper_bound0.pass.cpp          | 7 +++----
 .../associative/map/map.ops/upper_bound1.fail.cpp          | 7 +++----
 .../associative/map/map.ops/upper_bound2.fail.cpp          | 7 +++----
 .../associative/map/map.ops/upper_bound3.fail.cpp          | 7 +++----
 .../associative/map/map.special/member_swap.pass.cpp       | 7 +++----
 .../associative/map/map.special/non_member_swap.pass.cpp   | 7 +++----
 .../associative/map/map.special/swap_noexcept.pass.cpp     | 7 +++----
 test/std/containers/associative/map/types.pass.cpp         | 7 +++----
 .../associative/multimap/allocator_mismatch.fail.cpp       | 7 +++----
 test/std/containers/associative/multimap/empty.fail.cpp    | 7 +++----
 test/std/containers/associative/multimap/empty.pass.cpp    | 7 +++----
 .../associative/multimap/incomplete_type.pass.cpp          | 7 +++----
 test/std/containers/associative/multimap/iterator.pass.cpp | 7 +++----
 test/std/containers/associative/multimap/max_size.pass.cpp | 7 +++----
 .../associative/multimap/multimap.cons/alloc.pass.cpp      | 7 +++----
 .../multimap.cons/assign_initializer_list.pass.cpp         | 7 +++----
 .../associative/multimap/multimap.cons/compare.pass.cpp    | 7 +++----
 .../multimap/multimap.cons/compare_alloc.pass.cpp          | 7 +++----
 .../multimap.cons/compare_copy_constructible.fail.cpp      | 7 +++----
 .../associative/multimap/multimap.cons/copy.pass.cpp       | 7 +++----
 .../associative/multimap/multimap.cons/copy_alloc.pass.cpp | 7 +++----
 .../multimap/multimap.cons/copy_assign.pass.cpp            | 7 +++----
 .../associative/multimap/multimap.cons/default.pass.cpp    | 7 +++----
 .../multimap/multimap.cons/default_noexcept.pass.cpp       | 7 +++----
 .../multimap/multimap.cons/default_recursive.pass.cpp      | 7 +++----
 .../multimap/multimap.cons/dtor_noexcept.pass.cpp          | 7 +++----
 .../multimap/multimap.cons/initializer_list.pass.cpp       | 7 +++----
 .../multimap.cons/initializer_list_compare.pass.cpp        | 7 +++----
 .../multimap.cons/initializer_list_compare_alloc.pass.cpp  | 7 +++----
 .../associative/multimap/multimap.cons/iter_iter.pass.cpp  | 7 +++----
 .../multimap/multimap.cons/iter_iter_comp.pass.cpp         | 7 +++----
 .../multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp   | 7 +++----
 .../associative/multimap/multimap.cons/move.pass.cpp       | 7 +++----
 .../associative/multimap/multimap.cons/move_alloc.pass.cpp | 7 +++----
 .../multimap/multimap.cons/move_assign.pass.cpp            | 7 +++----
 .../multimap/multimap.cons/move_assign_noexcept.pass.cpp   | 7 +++----
 .../multimap/multimap.cons/move_noexcept.pass.cpp          | 7 +++----
 .../multimap/multimap.erasure/erase_if.pass.cpp            | 7 +++----
 .../associative/multimap/multimap.modifiers/clear.pass.cpp | 7 +++----
 .../multimap/multimap.modifiers/emplace.pass.cpp           | 7 +++----
 .../multimap/multimap.modifiers/emplace_hint.pass.cpp      | 7 +++----
 .../multimap/multimap.modifiers/erase_iter.pass.cpp        | 7 +++----
 .../multimap/multimap.modifiers/erase_iter_iter.pass.cpp   | 7 +++----
 .../multimap/multimap.modifiers/erase_key.pass.cpp         | 7 +++----
 .../multimap/multimap.modifiers/extract_iterator.pass.cpp  | 7 +++----
 .../multimap/multimap.modifiers/extract_key.pass.cpp       | 7 +++----
 .../insert_allocator_requirements.pass.cpp                 | 7 +++----
 .../multimap/multimap.modifiers/insert_cv.pass.cpp         | 7 +++----
 .../multimap.modifiers/insert_initializer_list.pass.cpp    | 7 +++----
 .../multimap/multimap.modifiers/insert_iter_cv.pass.cpp    | 7 +++----
 .../multimap/multimap.modifiers/insert_iter_iter.pass.cpp  | 7 +++----
 .../multimap/multimap.modifiers/insert_iter_rv.pass.cpp    | 7 +++----
 .../multimap/multimap.modifiers/insert_node_type.pass.cpp  | 7 +++----
 .../multimap.modifiers/insert_node_type_hint.pass.cpp      | 7 +++----
 .../multimap/multimap.modifiers/insert_rv.pass.cpp         | 7 +++----
 .../associative/multimap/multimap.modifiers/merge.pass.cpp | 7 +++----
 .../associative/multimap/multimap.ops/count.pass.cpp       | 7 +++----
 .../associative/multimap/multimap.ops/count0.pass.cpp      | 7 +++----
 .../associative/multimap/multimap.ops/count1.fail.cpp      | 7 +++----
 .../associative/multimap/multimap.ops/count2.fail.cpp      | 7 +++----
 .../associative/multimap/multimap.ops/count3.fail.cpp      | 7 +++----
 .../multimap/multimap.ops/count_transparent.pass.cpp       | 7 +++----
 .../associative/multimap/multimap.ops/equal_range.pass.cpp | 7 +++----
 .../multimap/multimap.ops/equal_range0.pass.cpp            | 7 +++----
 .../multimap/multimap.ops/equal_range1.fail.cpp            | 7 +++----
 .../multimap/multimap.ops/equal_range2.fail.cpp            | 7 +++----
 .../multimap/multimap.ops/equal_range3.fail.cpp            | 7 +++----
 .../multimap/multimap.ops/equal_range_transparent.pass.cpp | 7 +++----
 .../associative/multimap/multimap.ops/find.pass.cpp        | 7 +++----
 .../associative/multimap/multimap.ops/find0.pass.cpp       | 7 +++----
 .../associative/multimap/multimap.ops/find1.fail.cpp       | 7 +++----
 .../associative/multimap/multimap.ops/find2.fail.cpp       | 7 +++----
 .../associative/multimap/multimap.ops/find3.fail.cpp       | 7 +++----
 .../associative/multimap/multimap.ops/lower_bound.pass.cpp | 7 +++----
 .../multimap/multimap.ops/lower_bound0.pass.cpp            | 7 +++----
 .../multimap/multimap.ops/lower_bound1.fail.cpp            | 7 +++----
 .../multimap/multimap.ops/lower_bound2.fail.cpp            | 7 +++----
 .../multimap/multimap.ops/lower_bound3.fail.cpp            | 7 +++----
 .../associative/multimap/multimap.ops/upper_bound.pass.cpp | 7 +++----
 .../multimap/multimap.ops/upper_bound0.pass.cpp            | 7 +++----
 .../multimap/multimap.ops/upper_bound1.fail.cpp            | 7 +++----
 .../multimap/multimap.ops/upper_bound2.fail.cpp            | 7 +++----
 .../multimap/multimap.ops/upper_bound3.fail.cpp            | 7 +++----
 .../multimap/multimap.special/member_swap.pass.cpp         | 7 +++----
 .../multimap/multimap.special/non_member_swap.pass.cpp     | 7 +++----
 .../multimap/multimap.special/swap_noexcept.pass.cpp       | 7 +++----
 test/std/containers/associative/multimap/scary.pass.cpp    | 7 +++----
 test/std/containers/associative/multimap/size.pass.cpp     | 7 +++----
 test/std/containers/associative/multimap/types.pass.cpp    | 7 +++----
 .../associative/multiset/allocator_mismatch.fail.cpp       | 7 +++----
 test/std/containers/associative/multiset/clear.pass.cpp    | 7 +++----
 test/std/containers/associative/multiset/count.pass.cpp    | 7 +++----
 .../associative/multiset/count_transparent.pass.cpp        | 7 +++----
 test/std/containers/associative/multiset/emplace.pass.cpp  | 7 +++----
 .../containers/associative/multiset/emplace_hint.pass.cpp  | 7 +++----
 test/std/containers/associative/multiset/empty.fail.cpp    | 7 +++----
 test/std/containers/associative/multiset/empty.pass.cpp    | 7 +++----
 .../containers/associative/multiset/equal_range.pass.cpp   | 7 +++----
 .../associative/multiset/equal_range_transparent.pass.cpp  | 7 +++----
 .../containers/associative/multiset/erase_iter.pass.cpp    | 7 +++----
 .../associative/multiset/erase_iter_iter.pass.cpp          | 7 +++----
 .../std/containers/associative/multiset/erase_key.pass.cpp | 7 +++----
 .../associative/multiset/extract_iterator.pass.cpp         | 7 +++----
 .../containers/associative/multiset/extract_key.pass.cpp   | 7 +++----
 test/std/containers/associative/multiset/find.pass.cpp     | 7 +++----
 .../associative/multiset/incomplete_type.pass.cpp          | 7 +++----
 .../std/containers/associative/multiset/insert_cv.pass.cpp | 7 +++----
 .../insert_emplace_allocator_requirements.pass.cpp         | 7 +++----
 .../associative/multiset/insert_initializer_list.pass.cpp  | 7 +++----
 .../associative/multiset/insert_iter_cv.pass.cpp           | 7 +++----
 .../associative/multiset/insert_iter_iter.pass.cpp         | 7 +++----
 .../associative/multiset/insert_iter_rv.pass.cpp           | 7 +++----
 .../associative/multiset/insert_node_type.pass.cpp         | 7 +++----
 .../associative/multiset/insert_node_type_hint.pass.cpp    | 7 +++----
 .../std/containers/associative/multiset/insert_rv.pass.cpp | 7 +++----
 test/std/containers/associative/multiset/iterator.pass.cpp | 7 +++----
 .../containers/associative/multiset/lower_bound.pass.cpp   | 7 +++----
 test/std/containers/associative/multiset/max_size.pass.cpp | 7 +++----
 test/std/containers/associative/multiset/merge.pass.cpp    | 7 +++----
 .../associative/multiset/multiset.cons/alloc.pass.cpp      | 7 +++----
 .../multiset.cons/assign_initializer_list.pass.cpp         | 7 +++----
 .../associative/multiset/multiset.cons/compare.pass.cpp    | 7 +++----
 .../multiset/multiset.cons/compare_alloc.pass.cpp          | 7 +++----
 .../multiset.cons/compare_copy_constructible.fail.cpp      | 7 +++----
 .../associative/multiset/multiset.cons/copy.pass.cpp       | 7 +++----
 .../associative/multiset/multiset.cons/copy_alloc.pass.cpp | 7 +++----
 .../multiset/multiset.cons/copy_assign.pass.cpp            | 7 +++----
 .../associative/multiset/multiset.cons/default.pass.cpp    | 7 +++----
 .../multiset/multiset.cons/default_noexcept.pass.cpp       | 7 +++----
 .../multiset/multiset.cons/dtor_noexcept.pass.cpp          | 7 +++----
 .../multiset/multiset.cons/initializer_list.pass.cpp       | 7 +++----
 .../multiset.cons/initializer_list_compare.pass.cpp        | 7 +++----
 .../multiset.cons/initializer_list_compare_alloc.pass.cpp  | 7 +++----
 .../associative/multiset/multiset.cons/iter_iter.pass.cpp  | 7 +++----
 .../multiset/multiset.cons/iter_iter_alloc.pass.cpp        | 7 +++----
 .../multiset/multiset.cons/iter_iter_comp.pass.cpp         | 7 +++----
 .../associative/multiset/multiset.cons/move.pass.cpp       | 7 +++----
 .../associative/multiset/multiset.cons/move_alloc.pass.cpp | 7 +++----
 .../multiset/multiset.cons/move_assign.pass.cpp            | 7 +++----
 .../multiset/multiset.cons/move_assign_noexcept.pass.cpp   | 7 +++----
 .../multiset/multiset.cons/move_noexcept.pass.cpp          | 7 +++----
 .../multiset/multiset.erasure/erase_if.pass.cpp            | 7 +++----
 .../multiset/multiset.special/member_swap.pass.cpp         | 7 +++----
 .../multiset/multiset.special/non_member_swap.pass.cpp     | 7 +++----
 .../multiset/multiset.special/swap_noexcept.pass.cpp       | 7 +++----
 test/std/containers/associative/multiset/scary.pass.cpp    | 7 +++----
 test/std/containers/associative/multiset/size.pass.cpp     | 7 +++----
 test/std/containers/associative/multiset/types.pass.cpp    | 7 +++----
 .../containers/associative/multiset/upper_bound.pass.cpp   | 7 +++----
 .../containers/associative/set/allocator_mismatch.fail.cpp | 7 +++----
 test/std/containers/associative/set/clear.pass.cpp         | 7 +++----
 test/std/containers/associative/set/count.pass.cpp         | 7 +++----
 .../containers/associative/set/count_transparent.pass.cpp  | 7 +++----
 test/std/containers/associative/set/emplace.pass.cpp       | 7 +++----
 test/std/containers/associative/set/emplace_hint.pass.cpp  | 7 +++----
 test/std/containers/associative/set/empty.fail.cpp         | 7 +++----
 test/std/containers/associative/set/empty.pass.cpp         | 7 +++----
 test/std/containers/associative/set/equal_range.pass.cpp   | 7 +++----
 .../associative/set/equal_range_transparent.pass.cpp       | 7 +++----
 test/std/containers/associative/set/erase_iter.pass.cpp    | 7 +++----
 .../containers/associative/set/erase_iter_iter.pass.cpp    | 7 +++----
 test/std/containers/associative/set/erase_key.pass.cpp     | 7 +++----
 .../containers/associative/set/extract_iterator.pass.cpp   | 7 +++----
 test/std/containers/associative/set/extract_key.pass.cpp   | 7 +++----
 test/std/containers/associative/set/find.pass.cpp          | 7 +++----
 .../containers/associative/set/incomplete_type.pass.cpp    | 7 +++----
 .../set/insert_and_emplace_allocator_requirements.pass.cpp | 7 +++----
 test/std/containers/associative/set/insert_cv.pass.cpp     | 7 +++----
 .../associative/set/insert_initializer_list.pass.cpp       | 7 +++----
 .../std/containers/associative/set/insert_iter_cv.pass.cpp | 7 +++----
 .../containers/associative/set/insert_iter_iter.pass.cpp   | 7 +++----
 .../std/containers/associative/set/insert_iter_rv.pass.cpp | 7 +++----
 .../containers/associative/set/insert_node_type.pass.cpp   | 7 +++----
 .../associative/set/insert_node_type_hint.pass.cpp         | 7 +++----
 test/std/containers/associative/set/insert_rv.pass.cpp     | 7 +++----
 test/std/containers/associative/set/iterator.pass.cpp      | 7 +++----
 test/std/containers/associative/set/lower_bound.pass.cpp   | 7 +++----
 test/std/containers/associative/set/max_size.pass.cpp      | 7 +++----
 test/std/containers/associative/set/merge.pass.cpp         | 7 +++----
 .../std/containers/associative/set/set.cons/alloc.pass.cpp | 7 +++----
 .../set/set.cons/assign_initializer_list.pass.cpp          | 7 +++----
 .../containers/associative/set/set.cons/compare.pass.cpp   | 7 +++----
 .../associative/set/set.cons/compare_alloc.pass.cpp        | 7 +++----
 .../set/set.cons/compare_copy_constructible.fail.cpp       | 7 +++----
 test/std/containers/associative/set/set.cons/copy.pass.cpp | 7 +++----
 .../associative/set/set.cons/copy_alloc.pass.cpp           | 7 +++----
 .../associative/set/set.cons/copy_assign.pass.cpp          | 7 +++----
 .../containers/associative/set/set.cons/default.pass.cpp   | 7 +++----
 .../associative/set/set.cons/default_noexcept.pass.cpp     | 7 +++----
 .../associative/set/set.cons/dtor_noexcept.pass.cpp        | 7 +++----
 .../associative/set/set.cons/initializer_list.pass.cpp     | 7 +++----
 .../set/set.cons/initializer_list_compare.pass.cpp         | 7 +++----
 .../set/set.cons/initializer_list_compare_alloc.pass.cpp   | 7 +++----
 .../containers/associative/set/set.cons/iter_iter.pass.cpp | 7 +++----
 .../associative/set/set.cons/iter_iter_alloc.pass.cpp      | 7 +++----
 .../associative/set/set.cons/iter_iter_comp.pass.cpp       | 7 +++----
 test/std/containers/associative/set/set.cons/move.pass.cpp | 7 +++----
 .../associative/set/set.cons/move_alloc.pass.cpp           | 7 +++----
 .../associative/set/set.cons/move_assign.pass.cpp          | 7 +++----
 .../associative/set/set.cons/move_assign_noexcept.pass.cpp | 7 +++----
 .../associative/set/set.cons/move_noexcept.pass.cpp        | 7 +++----
 .../associative/set/set.erasure/erase_if.pass.cpp          | 7 +++----
 .../associative/set/set.special/member_swap.pass.cpp       | 7 +++----
 .../associative/set/set.special/non_member_swap.pass.cpp   | 7 +++----
 .../associative/set/set.special/swap_noexcept.pass.cpp     | 7 +++----
 test/std/containers/associative/set/size.pass.cpp          | 7 +++----
 test/std/containers/associative/set/types.pass.cpp         | 7 +++----
 test/std/containers/associative/set/upper_bound.pass.cpp   | 7 +++----
 .../containers/container.adaptors/nothing_to_do.pass.cpp   | 7 +++----
 .../priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp | 7 +++----
 .../priqueue.cons.alloc/ctor_comp_alloc.pass.cpp           | 7 +++----
 .../priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp      | 7 +++----
 .../priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp     | 7 +++----
 .../priqueue.cons.alloc/ctor_copy_alloc.pass.cpp           | 7 +++----
 .../priqueue.cons.alloc/ctor_move_alloc.pass.cpp           | 7 +++----
 .../priority.queue/priqueue.cons/assign_copy.pass.cpp      | 7 +++----
 .../priority.queue/priqueue.cons/assign_move.pass.cpp      | 7 +++----
 .../priority.queue/priqueue.cons/ctor_comp.pass.cpp        | 7 +++----
 .../priqueue.cons/ctor_comp_container.pass.cpp             | 7 +++----
 .../priqueue.cons/ctor_comp_rcontainer.pass.cpp            | 7 +++----
 .../priority.queue/priqueue.cons/ctor_copy.pass.cpp        | 7 +++----
 .../priority.queue/priqueue.cons/ctor_default.pass.cpp     | 7 +++----
 .../priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp   | 7 +++----
 .../priqueue.cons/ctor_iter_iter_comp.pass.cpp             | 7 +++----
 .../priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp        | 7 +++----
 .../priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp       | 7 +++----
 .../priority.queue/priqueue.cons/ctor_move.pass.cpp        | 7 +++----
 .../priority.queue/priqueue.cons/deduct.fail.cpp           | 7 +++----
 .../priority.queue/priqueue.cons/deduct.pass.cpp           | 7 +++----
 .../priority.queue/priqueue.cons/default_noexcept.pass.cpp | 7 +++----
 .../priority.queue/priqueue.cons/dtor_noexcept.pass.cpp    | 7 +++----
 .../priqueue.cons/move_assign_noexcept.pass.cpp            | 7 +++----
 .../priority.queue/priqueue.cons/move_noexcept.pass.cpp    | 7 +++----
 .../priority.queue/priqueue.members/emplace.pass.cpp       | 7 +++----
 .../priority.queue/priqueue.members/empty.fail.cpp         | 7 +++----
 .../priority.queue/priqueue.members/empty.pass.cpp         | 7 +++----
 .../priority.queue/priqueue.members/pop.pass.cpp           | 7 +++----
 .../priority.queue/priqueue.members/push.pass.cpp          | 7 +++----
 .../priority.queue/priqueue.members/push_rvalue.pass.cpp   | 7 +++----
 .../priority.queue/priqueue.members/size.pass.cpp          | 7 +++----
 .../priority.queue/priqueue.members/swap.pass.cpp          | 7 +++----
 .../priority.queue/priqueue.members/top.pass.cpp           | 7 +++----
 .../priority.queue/priqueue.special/swap.pass.cpp          | 7 +++----
 .../priority.queue/priqueue.special/swap_noexcept.pass.cpp | 7 +++----
 .../container.adaptors/priority.queue/types.fail.cpp       | 7 +++----
 .../container.adaptors/priority.queue/types.pass.cpp       | 7 +++----
 .../queue/queue.cons.alloc/ctor_alloc.pass.cpp             | 7 +++----
 .../queue/queue.cons.alloc/ctor_container_alloc.pass.cpp   | 7 +++----
 .../queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp       | 7 +++----
 .../queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp  | 7 +++----
 .../queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp      | 7 +++----
 .../queue/queue.cons/ctor_container.pass.cpp               | 7 +++----
 .../container.adaptors/queue/queue.cons/ctor_copy.pass.cpp | 7 +++----
 .../queue/queue.cons/ctor_default.pass.cpp                 | 7 +++----
 .../container.adaptors/queue/queue.cons/ctor_move.pass.cpp | 7 +++----
 .../queue/queue.cons/ctor_rcontainer.pass.cpp              | 7 +++----
 .../container.adaptors/queue/queue.cons/deduct.fail.cpp    | 7 +++----
 .../container.adaptors/queue/queue.cons/deduct.pass.cpp    | 7 +++----
 .../queue/queue.cons/default_noexcept.pass.cpp             | 7 +++----
 .../queue/queue.cons/dtor_noexcept.pass.cpp                | 7 +++----
 .../queue/queue.cons/move_assign_noexcept.pass.cpp         | 7 +++----
 .../queue/queue.cons/move_noexcept.pass.cpp                | 7 +++----
 .../queue/queue.defn/assign_copy.pass.cpp                  | 7 +++----
 .../queue/queue.defn/assign_move.pass.cpp                  | 7 +++----
 .../container.adaptors/queue/queue.defn/back.pass.cpp      | 7 +++----
 .../queue/queue.defn/back_const.pass.cpp                   | 7 +++----
 .../container.adaptors/queue/queue.defn/emplace.pass.cpp   | 7 +++----
 .../container.adaptors/queue/queue.defn/empty.fail.cpp     | 7 +++----
 .../container.adaptors/queue/queue.defn/empty.pass.cpp     | 7 +++----
 .../container.adaptors/queue/queue.defn/front.pass.cpp     | 7 +++----
 .../queue/queue.defn/front_const.pass.cpp                  | 7 +++----
 .../container.adaptors/queue/queue.defn/pop.pass.cpp       | 7 +++----
 .../container.adaptors/queue/queue.defn/push.pass.cpp      | 7 +++----
 .../container.adaptors/queue/queue.defn/push_rv.pass.cpp   | 7 +++----
 .../container.adaptors/queue/queue.defn/size.pass.cpp      | 7 +++----
 .../container.adaptors/queue/queue.defn/swap.pass.cpp      | 7 +++----
 .../container.adaptors/queue/queue.defn/types.fail.cpp     | 7 +++----
 .../container.adaptors/queue/queue.defn/types.pass.cpp     | 7 +++----
 .../container.adaptors/queue/queue.ops/eq.pass.cpp         | 7 +++----
 .../container.adaptors/queue/queue.ops/lt.pass.cpp         | 7 +++----
 .../container.adaptors/queue/queue.special/swap.pass.cpp   | 7 +++----
 .../queue/queue.special/swap_noexcept.pass.cpp             | 7 +++----
 .../stack/stack.cons.alloc/ctor_alloc.pass.cpp             | 7 +++----
 .../stack/stack.cons.alloc/ctor_container_alloc.pass.cpp   | 7 +++----
 .../stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp        | 7 +++----
 .../stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp  | 7 +++----
 .../stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp      | 7 +++----
 .../stack/stack.cons/ctor_container.pass.cpp               | 7 +++----
 .../container.adaptors/stack/stack.cons/ctor_copy.pass.cpp | 7 +++----
 .../stack/stack.cons/ctor_default.pass.cpp                 | 7 +++----
 .../container.adaptors/stack/stack.cons/ctor_move.pass.cpp | 7 +++----
 .../stack/stack.cons/ctor_rcontainer.pass.cpp              | 7 +++----
 .../container.adaptors/stack/stack.cons/deduct.fail.cpp    | 7 +++----
 .../container.adaptors/stack/stack.cons/deduct.pass.cpp    | 7 +++----
 .../stack/stack.cons/default_noexcept.pass.cpp             | 7 +++----
 .../stack/stack.cons/dtor_noexcept.pass.cpp                | 7 +++----
 .../stack/stack.cons/move_assign_noexcept.pass.cpp         | 7 +++----
 .../stack/stack.cons/move_noexcept.pass.cpp                | 7 +++----
 .../stack/stack.defn/assign_copy.pass.cpp                  | 7 +++----
 .../stack/stack.defn/assign_move.pass.cpp                  | 7 +++----
 .../container.adaptors/stack/stack.defn/emplace.pass.cpp   | 7 +++----
 .../container.adaptors/stack/stack.defn/empty.fail.cpp     | 7 +++----
 .../container.adaptors/stack/stack.defn/empty.pass.cpp     | 7 +++----
 .../container.adaptors/stack/stack.defn/pop.pass.cpp       | 7 +++----
 .../container.adaptors/stack/stack.defn/push.pass.cpp      | 7 +++----
 .../container.adaptors/stack/stack.defn/push_rv.pass.cpp   | 7 +++----
 .../container.adaptors/stack/stack.defn/size.pass.cpp      | 7 +++----
 .../container.adaptors/stack/stack.defn/swap.pass.cpp      | 7 +++----
 .../container.adaptors/stack/stack.defn/top.pass.cpp       | 7 +++----
 .../container.adaptors/stack/stack.defn/top_const.pass.cpp | 7 +++----
 .../container.adaptors/stack/stack.defn/types.fail.cpp     | 7 +++----
 .../container.adaptors/stack/stack.defn/types.pass.cpp     | 7 +++----
 .../container.adaptors/stack/stack.ops/eq.pass.cpp         | 7 +++----
 .../container.adaptors/stack/stack.ops/lt.pass.cpp         | 7 +++----
 .../container.adaptors/stack/stack.special/swap.pass.cpp   | 7 +++----
 .../stack/stack.special/swap_noexcept.pass.cpp             | 7 +++----
 test/std/containers/container.node/node_handle.pass.cpp    | 7 +++----
 .../associative.reqmts.except/nothing_to_do.pass.cpp       | 7 +++----
 .../associative.reqmts/nothing_to_do.pass.cpp              | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../container.requirements.general/allocator_move.pass.cpp | 7 +++----
 .../container.requirements.general/nothing_to_do.pass.cpp  | 7 +++----
 .../container.requirements/nothing_to_do.pass.cpp          | 7 +++----
 .../sequence.reqmts/nothing_to_do.pass.cpp                 | 7 +++----
 .../unord.req/nothing_to_do.pass.cpp                       | 7 +++----
 .../unord.req/unord.req.except/nothing_to_do.pass.cpp      | 7 +++----
 .../containers/containers.general/nothing_to_do.pass.cpp   | 7 +++----
 .../containers/map_allocator_requirement_test_templates.h  | 7 +++----
 test/std/containers/nothing_to_do.pass.cpp                 | 7 +++----
 .../containers/sequences/array/array.cons/deduct.fail.cpp  | 7 +++----
 .../containers/sequences/array/array.cons/deduct.pass.cpp  | 7 +++----
 .../containers/sequences/array/array.cons/default.pass.cpp | 7 +++----
 .../sequences/array/array.cons/implicit_copy.pass.cpp      | 7 +++----
 .../sequences/array/array.cons/initializer_list.pass.cpp   | 7 +++----
 .../containers/sequences/array/array.data/data.pass.cpp    | 7 +++----
 .../sequences/array/array.data/data_const.pass.cpp         | 7 +++----
 .../containers/sequences/array/array.fill/fill.fail.cpp    | 7 +++----
 .../containers/sequences/array/array.fill/fill.pass.cpp    | 7 +++----
 .../containers/sequences/array/array.size/size.pass.cpp    | 7 +++----
 .../containers/sequences/array/array.special/swap.pass.cpp | 7 +++----
 .../containers/sequences/array/array.swap/swap.fail.cpp    | 7 +++----
 .../containers/sequences/array/array.swap/swap.pass.cpp    | 7 +++----
 .../containers/sequences/array/array.tuple/get.fail.cpp    | 7 +++----
 .../containers/sequences/array/array.tuple/get.pass.cpp    | 7 +++----
 .../sequences/array/array.tuple/get_const.pass.cpp         | 7 +++----
 .../sequences/array/array.tuple/get_const_rv.pass.cpp      | 7 +++----
 .../containers/sequences/array/array.tuple/get_rv.pass.cpp | 7 +++----
 .../sequences/array/array.tuple/tuple_element.fail.cpp     | 7 +++----
 .../sequences/array/array.tuple/tuple_element.pass.cpp     | 7 +++----
 .../sequences/array/array.tuple/tuple_size.pass.cpp        | 7 +++----
 .../sequences/array/array.zero/tested_elsewhere.pass.cpp   | 7 +++----
 test/std/containers/sequences/array/at.pass.cpp            | 7 +++----
 test/std/containers/sequences/array/begin.pass.cpp         | 7 +++----
 test/std/containers/sequences/array/compare.fail.cpp       | 7 +++----
 test/std/containers/sequences/array/compare.pass.cpp       | 7 +++----
 test/std/containers/sequences/array/contiguous.pass.cpp    | 7 +++----
 test/std/containers/sequences/array/empty.fail.cpp         | 7 +++----
 test/std/containers/sequences/array/empty.pass.cpp         | 7 +++----
 test/std/containers/sequences/array/front_back.pass.cpp    | 7 +++----
 test/std/containers/sequences/array/indexing.pass.cpp      | 7 +++----
 test/std/containers/sequences/array/iterators.pass.cpp     | 7 +++----
 test/std/containers/sequences/array/max_size.pass.cpp      | 7 +++----
 .../containers/sequences/array/size_and_alignment.pass.cpp | 7 +++----
 test/std/containers/sequences/array/types.pass.cpp         | 7 +++----
 .../containers/sequences/deque/allocator_mismatch.fail.cpp | 7 +++----
 .../sequences/deque/deque.capacity/access.pass.cpp         | 7 +++----
 .../sequences/deque/deque.capacity/empty.fail.cpp          | 7 +++----
 .../sequences/deque/deque.capacity/empty.pass.cpp          | 7 +++----
 .../sequences/deque/deque.capacity/max_size.pass.cpp       | 7 +++----
 .../sequences/deque/deque.capacity/resize_size.pass.cpp    | 7 +++----
 .../deque/deque.capacity/resize_size_value.pass.cpp        | 7 +++----
 .../sequences/deque/deque.capacity/shrink_to_fit.pass.cpp  | 7 +++----
 .../sequences/deque/deque.capacity/size.pass.cpp           | 7 +++----
 .../containers/sequences/deque/deque.cons/alloc.pass.cpp   | 7 +++----
 .../deque/deque.cons/assign_initializer_list.pass.cpp      | 7 +++----
 .../sequences/deque/deque.cons/assign_iter_iter.pass.cpp   | 7 +++----
 .../sequences/deque/deque.cons/assign_size_value.pass.cpp  | 7 +++----
 .../containers/sequences/deque/deque.cons/copy.pass.cpp    | 7 +++----
 .../sequences/deque/deque.cons/copy_alloc.pass.cpp         | 7 +++----
 .../containers/sequences/deque/deque.cons/deduct.fail.cpp  | 7 +++----
 .../containers/sequences/deque/deque.cons/deduct.pass.cpp  | 7 +++----
 .../containers/sequences/deque/deque.cons/default.pass.cpp | 7 +++----
 .../sequences/deque/deque.cons/default_noexcept.pass.cpp   | 7 +++----
 .../sequences/deque/deque.cons/dtor_noexcept.pass.cpp      | 7 +++----
 .../sequences/deque/deque.cons/initializer_list.pass.cpp   | 7 +++----
 .../deque/deque.cons/initializer_list_alloc.pass.cpp       | 7 +++----
 .../sequences/deque/deque.cons/iter_iter.pass.cpp          | 7 +++----
 .../sequences/deque/deque.cons/iter_iter_alloc.pass.cpp    | 7 +++----
 .../containers/sequences/deque/deque.cons/move.pass.cpp    | 7 +++----
 .../sequences/deque/deque.cons/move_alloc.pass.cpp         | 7 +++----
 .../sequences/deque/deque.cons/move_assign.pass.cpp        | 7 +++----
 .../deque/deque.cons/move_assign_noexcept.pass.cpp         | 7 +++----
 .../sequences/deque/deque.cons/move_noexcept.pass.cpp      | 7 +++----
 .../sequences/deque/deque.cons/op_equal.pass.cpp           | 7 +++----
 .../deque/deque.cons/op_equal_initializer_list.pass.cpp    | 7 +++----
 .../containers/sequences/deque/deque.cons/size.pass.cpp    | 7 +++----
 .../sequences/deque/deque.cons/size_value.pass.cpp         | 7 +++----
 .../sequences/deque/deque.cons/size_value_alloc.pass.cpp   | 7 +++----
 .../sequences/deque/deque.erasure/erase.pass.cpp           | 7 +++----
 .../sequences/deque/deque.erasure/erase_if.pass.cpp        | 7 +++----
 .../sequences/deque/deque.modifiers/clear.pass.cpp         | 7 +++----
 .../sequences/deque/deque.modifiers/emplace.pass.cpp       | 7 +++----
 .../sequences/deque/deque.modifiers/emplace_back.pass.cpp  | 7 +++----
 .../sequences/deque/deque.modifiers/emplace_front.pass.cpp | 7 +++----
 .../deque/deque.modifiers/erase_iter.invalidation.pass.cpp | 7 +++----
 .../sequences/deque/deque.modifiers/erase_iter.pass.cpp    | 7 +++----
 .../deque.modifiers/erase_iter_iter.invalidation.pass.cpp  | 7 +++----
 .../deque/deque.modifiers/erase_iter_iter.pass.cpp         | 7 +++----
 .../deque.modifiers/insert_iter_initializer_list.pass.cpp  | 7 +++----
 .../deque/deque.modifiers/insert_iter_iter.pass.cpp        | 7 +++----
 .../sequences/deque/deque.modifiers/insert_rvalue.pass.cpp | 7 +++----
 .../deque/deque.modifiers/insert_size_value.pass.cpp       | 7 +++----
 .../sequences/deque/deque.modifiers/insert_value.pass.cpp  | 7 +++----
 .../deque/deque.modifiers/pop_back.invalidation.pass.cpp   | 7 +++----
 .../sequences/deque/deque.modifiers/pop_back.pass.cpp      | 7 +++----
 .../deque/deque.modifiers/pop_front.invalidation.pass.cpp  | 7 +++----
 .../sequences/deque/deque.modifiers/pop_front.pass.cpp     | 7 +++----
 .../sequences/deque/deque.modifiers/push_back.pass.cpp     | 7 +++----
 .../deque.modifiers/push_back_exception_safety.pass.cpp    | 7 +++----
 .../deque/deque.modifiers/push_back_rvalue.pass.cpp        | 7 +++----
 .../sequences/deque/deque.modifiers/push_front.pass.cpp    | 7 +++----
 .../deque.modifiers/push_front_exception_safety.pass.cpp   | 7 +++----
 .../deque/deque.modifiers/push_front_rvalue.pass.cpp       | 7 +++----
 .../containers/sequences/deque/deque.special/copy.pass.cpp | 7 +++----
 .../sequences/deque/deque.special/copy_backward.pass.cpp   | 7 +++----
 .../containers/sequences/deque/deque.special/move.pass.cpp | 7 +++----
 .../sequences/deque/deque.special/move_backward.pass.cpp   | 7 +++----
 .../containers/sequences/deque/deque.special/swap.pass.cpp | 7 +++----
 .../sequences/deque/deque.special/swap_noexcept.pass.cpp   | 7 +++----
 test/std/containers/sequences/deque/iterators.pass.cpp     | 7 +++----
 test/std/containers/sequences/deque/types.pass.cpp         | 7 +++----
 .../sequences/forwardlist/allocator_mismatch.fail.cpp      | 7 +++----
 test/std/containers/sequences/forwardlist/empty.fail.cpp   | 7 +++----
 test/std/containers/sequences/forwardlist/empty.pass.cpp   | 7 +++----
 .../forwardlist/forwardlist.access/front.pass.cpp          | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/alloc.fail.cpp  | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/alloc.pass.cpp  | 7 +++----
 .../forwardlist/forwardlist.cons/assign_copy.pass.cpp      | 7 +++----
 .../forwardlist/forwardlist.cons/assign_init.pass.cpp      | 7 +++----
 .../forwardlist/forwardlist.cons/assign_move.pass.cpp      | 7 +++----
 .../forwardlist/forwardlist.cons/assign_op_init.pass.cpp   | 7 +++----
 .../forwardlist/forwardlist.cons/assign_range.pass.cpp     | 7 +++----
 .../forwardlist.cons/assign_size_value.pass.cpp            | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/copy.pass.cpp   | 7 +++----
 .../forwardlist/forwardlist.cons/copy_alloc.pass.cpp       | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/deduct.fail.cpp | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/deduct.pass.cpp | 7 +++----
 .../forwardlist/forwardlist.cons/default.pass.cpp          | 7 +++----
 .../forwardlist/forwardlist.cons/default_noexcept.pass.cpp | 7 +++----
 .../forwardlist.cons/default_recursive.pass.cpp            | 7 +++----
 .../forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp    | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/init.pass.cpp   | 7 +++----
 .../forwardlist/forwardlist.cons/init_alloc.pass.cpp       | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/move.pass.cpp   | 7 +++----
 .../forwardlist/forwardlist.cons/move_alloc.pass.cpp       | 7 +++----
 .../forwardlist.cons/move_assign_noexcept.pass.cpp         | 7 +++----
 .../forwardlist/forwardlist.cons/move_noexcept.pass.cpp    | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/range.pass.cpp  | 7 +++----
 .../forwardlist/forwardlist.cons/range_alloc.pass.cpp      | 7 +++----
 .../sequences/forwardlist/forwardlist.cons/size.pass.cpp   | 7 +++----
 .../forwardlist/forwardlist.cons/size_value.pass.cpp       | 7 +++----
 .../forwardlist/forwardlist.cons/size_value_alloc.pass.cpp | 7 +++----
 .../forwardlist/forwardlist.erasure/erase.pass.cpp         | 7 +++----
 .../forwardlist/forwardlist.erasure/erase_if.pass.cpp      | 7 +++----
 .../forwardlist/forwardlist.iter/before_begin.pass.cpp     | 7 +++----
 .../forwardlist/forwardlist.iter/iterators.pass.cpp        | 7 +++----
 .../forwardlist/forwardlist.modifiers/clear.pass.cpp       | 7 +++----
 .../forwardlist.modifiers/emplace_after.pass.cpp           | 7 +++----
 .../forwardlist.modifiers/emplace_front.pass.cpp           | 7 +++----
 .../forwardlist.modifiers/erase_after_many.pass.cpp        | 7 +++----
 .../forwardlist.modifiers/erase_after_one.pass.cpp         | 7 +++----
 .../forwardlist.modifiers/insert_after_const.pass.cpp      | 7 +++----
 .../forwardlist.modifiers/insert_after_init.pass.cpp       | 7 +++----
 .../forwardlist.modifiers/insert_after_range.pass.cpp      | 7 +++----
 .../forwardlist.modifiers/insert_after_rv.pass.cpp         | 7 +++----
 .../forwardlist.modifiers/insert_after_size_value.pass.cpp | 7 +++----
 .../forwardlist/forwardlist.modifiers/pop_front.pass.cpp   | 7 +++----
 .../forwardlist.modifiers/push_front_const.pass.cpp        | 7 +++----
 .../push_front_exception_safety.pass.cpp                   | 7 +++----
 .../forwardlist.modifiers/push_front_rv.pass.cpp           | 7 +++----
 .../forwardlist/forwardlist.modifiers/resize_size.pass.cpp | 7 +++----
 .../forwardlist.modifiers/resize_size_value.pass.cpp       | 7 +++----
 .../sequences/forwardlist/forwardlist.ops/merge.pass.cpp   | 7 +++----
 .../forwardlist/forwardlist.ops/merge_pred.pass.cpp        | 7 +++----
 .../sequences/forwardlist/forwardlist.ops/remove.pass.cpp  | 7 +++----
 .../forwardlist/forwardlist.ops/remove_if.pass.cpp         | 7 +++----
 .../sequences/forwardlist/forwardlist.ops/reverse.pass.cpp | 7 +++----
 .../sequences/forwardlist/forwardlist.ops/sort.pass.cpp    | 7 +++----
 .../forwardlist/forwardlist.ops/sort_pred.pass.cpp         | 7 +++----
 .../forwardlist.ops/splice_after_flist.pass.cpp            | 7 +++----
 .../forwardlist/forwardlist.ops/splice_after_one.pass.cpp  | 7 +++----
 .../forwardlist.ops/splice_after_range.pass.cpp            | 7 +++----
 .../sequences/forwardlist/forwardlist.ops/unique.pass.cpp  | 7 +++----
 .../forwardlist/forwardlist.ops/unique_pred.pass.cpp       | 7 +++----
 .../containers/sequences/forwardlist/incomplete.pass.cpp   | 7 +++----
 .../std/containers/sequences/forwardlist/max_size.pass.cpp | 7 +++----
 test/std/containers/sequences/forwardlist/types.pass.cpp   | 7 +++----
 .../containers/sequences/list/allocator_mismatch.fail.cpp  | 7 +++----
 .../std/containers/sequences/list/incomplete_type.pass.cpp | 7 +++----
 test/std/containers/sequences/list/iterators.pass.cpp      | 7 +++----
 .../containers/sequences/list/list.capacity/empty.fail.cpp | 7 +++----
 .../containers/sequences/list/list.capacity/empty.pass.cpp | 7 +++----
 .../sequences/list/list.capacity/max_size.pass.cpp         | 7 +++----
 .../sequences/list/list.capacity/resize_size.pass.cpp      | 7 +++----
 .../list/list.capacity/resize_size_value.pass.cpp          | 7 +++----
 .../containers/sequences/list/list.capacity/size.pass.cpp  | 7 +++----
 .../sequences/list/list.cons/assign_copy.pass.cpp          | 7 +++----
 .../list/list.cons/assign_initializer_list.pass.cpp        | 7 +++----
 .../sequences/list/list.cons/assign_move.pass.cpp          | 7 +++----
 test/std/containers/sequences/list/list.cons/copy.pass.cpp | 7 +++----
 .../sequences/list/list.cons/copy_alloc.pass.cpp           | 7 +++----
 .../containers/sequences/list/list.cons/deduct.fail.cpp    | 7 +++----
 .../containers/sequences/list/list.cons/deduct.pass.cpp    | 7 +++----
 .../containers/sequences/list/list.cons/default.pass.cpp   | 7 +++----
 .../sequences/list/list.cons/default_noexcept.pass.cpp     | 7 +++----
 .../sequences/list/list.cons/default_stack_alloc.pass.cpp  | 7 +++----
 .../sequences/list/list.cons/dtor_noexcept.pass.cpp        | 7 +++----
 .../sequences/list/list.cons/initializer_list.pass.cpp     | 7 +++----
 .../list/list.cons/initializer_list_alloc.pass.cpp         | 7 +++----
 .../sequences/list/list.cons/input_iterator.pass.cpp       | 7 +++----
 test/std/containers/sequences/list/list.cons/move.pass.cpp | 7 +++----
 .../sequences/list/list.cons/move_alloc.pass.cpp           | 7 +++----
 .../sequences/list/list.cons/move_assign_noexcept.pass.cpp | 7 +++----
 .../sequences/list/list.cons/move_noexcept.pass.cpp        | 7 +++----
 .../list/list.cons/op_equal_initializer_list.pass.cpp      | 7 +++----
 .../containers/sequences/list/list.cons/size_type.pass.cpp | 7 +++----
 .../sequences/list/list.cons/size_value_alloc.pass.cpp     | 7 +++----
 .../containers/sequences/list/list.erasure/erase.pass.cpp  | 7 +++----
 .../sequences/list/list.erasure/erase_if.pass.cpp          | 7 +++----
 .../sequences/list/list.modifiers/clear.pass.cpp           | 7 +++----
 .../sequences/list/list.modifiers/emplace.pass.cpp         | 7 +++----
 .../sequences/list/list.modifiers/emplace_back.pass.cpp    | 7 +++----
 .../sequences/list/list.modifiers/emplace_front.pass.cpp   | 7 +++----
 .../sequences/list/list.modifiers/erase_iter.pass.cpp      | 7 +++----
 .../sequences/list/list.modifiers/erase_iter_iter.pass.cpp | 7 +++----
 .../list.modifiers/insert_iter_initializer_list.pass.cpp   | 7 +++----
 .../list/list.modifiers/insert_iter_iter_iter.pass.cpp     | 7 +++----
 .../list/list.modifiers/insert_iter_rvalue.pass.cpp        | 7 +++----
 .../list/list.modifiers/insert_iter_size_value.pass.cpp    | 7 +++----
 .../list/list.modifiers/insert_iter_value.pass.cpp         | 7 +++----
 .../sequences/list/list.modifiers/pop_back.pass.cpp        | 7 +++----
 .../sequences/list/list.modifiers/pop_front.pass.cpp       | 7 +++----
 .../sequences/list/list.modifiers/push_back.pass.cpp       | 7 +++----
 .../list.modifiers/push_back_exception_safety.pass.cpp     | 7 +++----
 .../list/list.modifiers/push_back_rvalue.pass.cpp          | 7 +++----
 .../sequences/list/list.modifiers/push_front.pass.cpp      | 7 +++----
 .../list.modifiers/push_front_exception_safety.pass.cpp    | 7 +++----
 .../list/list.modifiers/push_front_rvalue.pass.cpp         | 7 +++----
 test/std/containers/sequences/list/list.ops/merge.pass.cpp | 7 +++----
 .../containers/sequences/list/list.ops/merge_comp.pass.cpp | 7 +++----
 .../std/containers/sequences/list/list.ops/remove.pass.cpp | 7 +++----
 .../containers/sequences/list/list.ops/remove_if.pass.cpp  | 7 +++----
 .../containers/sequences/list/list.ops/reverse.pass.cpp    | 7 +++----
 test/std/containers/sequences/list/list.ops/sort.pass.cpp  | 7 +++----
 .../containers/sequences/list/list.ops/sort_comp.pass.cpp  | 7 +++----
 .../sequences/list/list.ops/splice_pos_list.pass.cpp       | 7 +++----
 .../sequences/list/list.ops/splice_pos_list_iter.pass.cpp  | 7 +++----
 .../list/list.ops/splice_pos_list_iter_iter.pass.cpp       | 7 +++----
 .../std/containers/sequences/list/list.ops/unique.pass.cpp | 7 +++----
 .../sequences/list/list.ops/unique_pred.pass.cpp           | 7 +++----
 .../containers/sequences/list/list.special/swap.pass.cpp   | 7 +++----
 .../sequences/list/list.special/swap_noexcept.pass.cpp     | 7 +++----
 test/std/containers/sequences/list/types.pass.cpp          | 7 +++----
 test/std/containers/sequences/nothing_to_do.pass.cpp       | 7 +++----
 .../containers/sequences/vector.bool/assign_copy.pass.cpp  | 7 +++----
 .../sequences/vector.bool/assign_initializer_list.pass.cpp | 7 +++----
 .../containers/sequences/vector.bool/assign_move.pass.cpp  | 7 +++----
 .../std/containers/sequences/vector.bool/capacity.pass.cpp | 7 +++----
 .../sequences/vector.bool/construct_default.pass.cpp       | 7 +++----
 .../sequences/vector.bool/construct_iter_iter.pass.cpp     | 7 +++----
 .../vector.bool/construct_iter_iter_alloc.pass.cpp         | 7 +++----
 .../sequences/vector.bool/construct_size.pass.cpp          | 7 +++----
 .../sequences/vector.bool/construct_size_value.pass.cpp    | 7 +++----
 .../vector.bool/construct_size_value_alloc.pass.cpp        | 7 +++----
 test/std/containers/sequences/vector.bool/copy.pass.cpp    | 7 +++----
 .../containers/sequences/vector.bool/copy_alloc.pass.cpp   | 7 +++----
 .../sequences/vector.bool/default_noexcept.pass.cpp        | 7 +++----
 .../sequences/vector.bool/dtor_noexcept.pass.cpp           | 7 +++----
 test/std/containers/sequences/vector.bool/emplace.pass.cpp | 7 +++----
 .../containers/sequences/vector.bool/emplace_back.pass.cpp | 7 +++----
 test/std/containers/sequences/vector.bool/empty.fail.cpp   | 7 +++----
 test/std/containers/sequences/vector.bool/empty.pass.cpp   | 7 +++----
 .../containers/sequences/vector.bool/enabled_hash.pass.cpp | 7 +++----
 .../containers/sequences/vector.bool/erase_iter.pass.cpp   | 7 +++----
 .../sequences/vector.bool/erase_iter_iter.pass.cpp         | 7 +++----
 test/std/containers/sequences/vector.bool/find.pass.cpp    | 7 +++----
 .../sequences/vector.bool/initializer_list.pass.cpp        | 7 +++----
 .../sequences/vector.bool/initializer_list_alloc.pass.cpp  | 7 +++----
 .../vector.bool/insert_iter_initializer_list.pass.cpp      | 7 +++----
 .../sequences/vector.bool/insert_iter_iter_iter.pass.cpp   | 7 +++----
 .../sequences/vector.bool/insert_iter_size_value.pass.cpp  | 7 +++----
 .../sequences/vector.bool/insert_iter_value.pass.cpp       | 7 +++----
 .../containers/sequences/vector.bool/iterators.pass.cpp    | 7 +++----
 test/std/containers/sequences/vector.bool/move.pass.cpp    | 7 +++----
 .../containers/sequences/vector.bool/move_alloc.pass.cpp   | 7 +++----
 .../sequences/vector.bool/move_assign_noexcept.pass.cpp    | 7 +++----
 .../sequences/vector.bool/move_noexcept.pass.cpp           | 7 +++----
 .../vector.bool/op_equal_initializer_list.pass.cpp         | 7 +++----
 .../containers/sequences/vector.bool/push_back.pass.cpp    | 7 +++----
 .../sequences/vector.bool/reference.swap.pass.cpp          | 7 +++----
 test/std/containers/sequences/vector.bool/reserve.pass.cpp | 7 +++----
 .../containers/sequences/vector.bool/resize_size.pass.cpp  | 7 +++----
 .../sequences/vector.bool/resize_size_value.pass.cpp       | 7 +++----
 .../sequences/vector.bool/shrink_to_fit.pass.cpp           | 7 +++----
 test/std/containers/sequences/vector.bool/size.pass.cpp    | 7 +++----
 test/std/containers/sequences/vector.bool/swap.pass.cpp    | 7 +++----
 .../sequences/vector.bool/swap_noexcept.pass.cpp           | 7 +++----
 test/std/containers/sequences/vector.bool/types.pass.cpp   | 7 +++----
 .../containers/sequences/vector.bool/vector_bool.pass.cpp  | 7 +++----
 .../sequences/vector/allocator_mismatch.fail.cpp           | 7 +++----
 test/std/containers/sequences/vector/contiguous.pass.cpp   | 7 +++----
 test/std/containers/sequences/vector/iterators.pass.cpp    | 7 +++----
 test/std/containers/sequences/vector/types.pass.cpp        | 7 +++----
 .../sequences/vector/vector.capacity/capacity.pass.cpp     | 7 +++----
 .../sequences/vector/vector.capacity/empty.fail.cpp        | 7 +++----
 .../sequences/vector/vector.capacity/empty.pass.cpp        | 7 +++----
 .../sequences/vector/vector.capacity/max_size.pass.cpp     | 7 +++----
 .../sequences/vector/vector.capacity/reserve.pass.cpp      | 7 +++----
 .../sequences/vector/vector.capacity/resize_size.pass.cpp  | 7 +++----
 .../vector/vector.capacity/resize_size_value.pass.cpp      | 7 +++----
 .../vector/vector.capacity/shrink_to_fit.pass.cpp          | 7 +++----
 .../sequences/vector/vector.capacity/size.pass.cpp         | 7 +++----
 .../sequences/vector/vector.capacity/swap.pass.cpp         | 7 +++----
 .../sequences/vector/vector.cons/assign_copy.pass.cpp      | 7 +++----
 .../vector/vector.cons/assign_initializer_list.pass.cpp    | 7 +++----
 .../sequences/vector/vector.cons/assign_iter_iter.pass.cpp | 7 +++----
 .../sequences/vector/vector.cons/assign_move.pass.cpp      | 7 +++----
 .../vector/vector.cons/assign_size_value.pass.cpp          | 7 +++----
 .../vector/vector.cons/construct_default.pass.cpp          | 7 +++----
 .../vector/vector.cons/construct_iter_iter.pass.cpp        | 7 +++----
 .../vector/vector.cons/construct_iter_iter_alloc.pass.cpp  | 7 +++----
 .../sequences/vector/vector.cons/construct_size.pass.cpp   | 7 +++----
 .../vector/vector.cons/construct_size_value.pass.cpp       | 7 +++----
 .../vector/vector.cons/construct_size_value_alloc.pass.cpp | 7 +++----
 .../containers/sequences/vector/vector.cons/copy.pass.cpp  | 7 +++----
 .../sequences/vector/vector.cons/copy_alloc.pass.cpp       | 7 +++----
 .../sequences/vector/vector.cons/deduct.fail.cpp           | 7 +++----
 .../sequences/vector/vector.cons/deduct.pass.cpp           | 7 +++----
 .../vector/vector.cons/default.recursive.pass.cpp          | 7 +++----
 .../sequences/vector/vector.cons/default_noexcept.pass.cpp | 7 +++----
 .../sequences/vector/vector.cons/dtor_noexcept.pass.cpp    | 7 +++----
 .../sequences/vector/vector.cons/initializer_list.pass.cpp | 7 +++----
 .../vector/vector.cons/initializer_list_alloc.pass.cpp     | 7 +++----
 .../containers/sequences/vector/vector.cons/move.pass.cpp  | 7 +++----
 .../sequences/vector/vector.cons/move_alloc.pass.cpp       | 7 +++----
 .../vector/vector.cons/move_assign_noexcept.pass.cpp       | 7 +++----
 .../sequences/vector/vector.cons/move_noexcept.pass.cpp    | 7 +++----
 .../vector/vector.cons/op_equal_initializer_list.pass.cpp  | 7 +++----
 .../containers/sequences/vector/vector.data/data.pass.cpp  | 7 +++----
 .../sequences/vector/vector.data/data_const.pass.cpp       | 7 +++----
 .../sequences/vector/vector.erasure/erase.pass.cpp         | 7 +++----
 .../sequences/vector/vector.erasure/erase_if.pass.cpp      | 7 +++----
 .../sequences/vector/vector.modifiers/clear.pass.cpp       | 7 +++----
 .../sequences/vector/vector.modifiers/emplace.pass.cpp     | 7 +++----
 .../vector/vector.modifiers/emplace_back.pass.cpp          | 7 +++----
 .../vector/vector.modifiers/emplace_extra.pass.cpp         | 7 +++----
 .../sequences/vector/vector.modifiers/erase_iter.pass.cpp  | 7 +++----
 .../vector/vector.modifiers/erase_iter_iter.pass.cpp       | 7 +++----
 .../vector.modifiers/insert_iter_initializer_list.pass.cpp | 7 +++----
 .../vector/vector.modifiers/insert_iter_iter_iter.pass.cpp | 7 +++----
 .../vector/vector.modifiers/insert_iter_rvalue.pass.cpp    | 7 +++----
 .../vector.modifiers/insert_iter_size_value.pass.cpp       | 7 +++----
 .../vector/vector.modifiers/insert_iter_value.pass.cpp     | 7 +++----
 .../sequences/vector/vector.modifiers/pop_back.pass.cpp    | 7 +++----
 .../sequences/vector/vector.modifiers/push_back.pass.cpp   | 7 +++----
 .../vector.modifiers/push_back_exception_safety.pass.cpp   | 7 +++----
 .../vector/vector.modifiers/push_back_rvalue.pass.cpp      | 7 +++----
 .../sequences/vector/vector.special/swap.pass.cpp          | 7 +++----
 .../sequences/vector/vector.special/swap_noexcept.pass.cpp | 7 +++----
 .../containers/set_allocator_requirement_test_templates.h  | 7 +++----
 test/std/containers/test_compare.h                         | 7 +++----
 test/std/containers/test_hash.h                            | 7 +++----
 .../std/containers/unord/iterator_difference_type.pass.cpp | 7 +++----
 .../containers/unord/unord.map/allocator_mismatch.fail.cpp | 7 +++----
 test/std/containers/unord/unord.map/bucket.pass.cpp        | 7 +++----
 test/std/containers/unord/unord.map/bucket_count.pass.cpp  | 7 +++----
 test/std/containers/unord/unord.map/bucket_size.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.map/compare.pass.cpp       | 7 +++----
 test/std/containers/unord/unord.map/count.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.map/empty.fail.cpp         | 7 +++----
 test/std/containers/unord/unord.map/empty.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.map/eq.pass.cpp            | 7 +++----
 .../containers/unord/unord.map/equal_range_const.pass.cpp  | 7 +++----
 .../unord/unord.map/equal_range_non_const.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.map/erase_if.pass.cpp      | 7 +++----
 test/std/containers/unord/unord.map/find_const.pass.cpp    | 7 +++----
 .../std/containers/unord/unord.map/find_non_const.pass.cpp | 7 +++----
 .../containers/unord/unord.map/incomplete_type.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.map/iterators.pass.cpp     | 7 +++----
 test/std/containers/unord/unord.map/load_factor.pass.cpp   | 7 +++----
 .../containers/unord/unord.map/local_iterators.pass.cpp    | 7 +++----
 .../containers/unord/unord.map/max_bucket_count.pass.cpp   | 7 +++----
 .../containers/unord/unord.map/max_load_factor.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.map/max_size.pass.cpp      | 7 +++----
 test/std/containers/unord/unord.map/rehash.pass.cpp        | 7 +++----
 test/std/containers/unord/unord.map/reserve.pass.cpp       | 7 +++----
 test/std/containers/unord/unord.map/size.pass.cpp          | 7 +++----
 test/std/containers/unord/unord.map/swap_member.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.map/types.pass.cpp         | 7 +++----
 .../unord/unord.map/unord.map.cnstr/allocator.pass.cpp     | 7 +++----
 .../unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp   | 7 +++----
 .../unord/unord.map/unord.map.cnstr/assign_init.pass.cpp   | 7 +++----
 .../unord/unord.map/unord.map.cnstr/assign_move.pass.cpp   | 7 +++----
 .../unord.map.cnstr/compare_copy_constructible.fail.cpp    | 7 +++----
 .../unord/unord.map/unord.map.cnstr/copy.pass.cpp          | 7 +++----
 .../unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp    | 7 +++----
 .../unord/unord.map/unord.map.cnstr/default.pass.cpp       | 7 +++----
 .../unord.map/unord.map.cnstr/default_noexcept.pass.cpp    | 7 +++----
 .../unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp | 7 +++----
 .../unord.map.cnstr/hash_copy_constructible.fail.cpp       | 7 +++----
 .../unord/unord.map/unord.map.cnstr/init.pass.cpp          | 7 +++----
 .../unord/unord.map/unord.map.cnstr/init_size.pass.cpp     | 7 +++----
 .../unord.map/unord.map.cnstr/init_size_hash.pass.cpp      | 7 +++----
 .../unord.map.cnstr/init_size_hash_equal.pass.cpp          | 7 +++----
 .../init_size_hash_equal_allocator.pass.cpp                | 7 +++----
 .../unord/unord.map/unord.map.cnstr/move.pass.cpp          | 7 +++----
 .../unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp    | 7 +++----
 .../unord.map.cnstr/move_assign_noexcept.pass.cpp          | 7 +++----
 .../unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp | 7 +++----
 .../unord/unord.map/unord.map.cnstr/range.pass.cpp         | 7 +++----
 .../unord/unord.map/unord.map.cnstr/range_size.pass.cpp    | 7 +++----
 .../unord.map/unord.map.cnstr/range_size_hash.pass.cpp     | 7 +++----
 .../unord.map.cnstr/range_size_hash_equal.pass.cpp         | 7 +++----
 .../range_size_hash_equal_allocator.pass.cpp               | 7 +++----
 .../unord/unord.map/unord.map.cnstr/size.fail.cpp          | 7 +++----
 .../unord/unord.map/unord.map.cnstr/size.pass.cpp          | 7 +++----
 .../unord/unord.map/unord.map.cnstr/size_hash.pass.cpp     | 7 +++----
 .../unord.map/unord.map.cnstr/size_hash_equal.pass.cpp     | 7 +++----
 .../unord.map.cnstr/size_hash_equal_allocator.pass.cpp     | 7 +++----
 .../containers/unord/unord.map/unord.map.elem/at.pass.cpp  | 7 +++----
 .../unord/unord.map/unord.map.elem/index.pass.cpp          | 7 +++----
 .../unord/unord.map/unord.map.elem/index_tuple.pass.cpp    | 7 +++----
 .../unord/unord.map/unord.map.modifiers/clear.pass.cpp     | 7 +++----
 .../unord/unord.map/unord.map.modifiers/emplace.pass.cpp   | 7 +++----
 .../unord.map/unord.map.modifiers/emplace_hint.pass.cpp    | 7 +++----
 .../unord.map.modifiers/erase_const_iter.pass.cpp          | 7 +++----
 .../unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp  | 7 +++----
 .../unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp  | 7 +++----
 .../unord.map.modifiers/erase_iter_iter_db1.pass.cpp       | 7 +++----
 .../unord.map.modifiers/erase_iter_iter_db2.pass.cpp       | 7 +++----
 .../unord.map.modifiers/erase_iter_iter_db3.pass.cpp       | 7 +++----
 .../unord.map.modifiers/erase_iter_iter_db4.pass.cpp       | 7 +++----
 .../unord/unord.map/unord.map.modifiers/erase_key.pass.cpp | 7 +++----
 .../unord.map/unord.map.modifiers/erase_range.pass.cpp     | 7 +++----
 .../unord.map.modifiers/extract_iterator.pass.cpp          | 7 +++----
 .../unord.map/unord.map.modifiers/extract_key.pass.cpp     | 7 +++----
 .../insert_and_emplace_allocator_requirements.pass.cpp     | 7 +++----
 .../unord.map.modifiers/insert_const_lvalue.pass.cpp       | 7 +++----
 .../unord.map.modifiers/insert_hint_const_lvalue.pass.cpp  | 7 +++----
 .../unord.map.modifiers/insert_hint_rvalue.pass.cpp        | 7 +++----
 .../unord.map/unord.map.modifiers/insert_init.pass.cpp     | 7 +++----
 .../unord.map.modifiers/insert_node_type.pass.cpp          | 7 +++----
 .../unord.map.modifiers/insert_node_type_hint.pass.cpp     | 7 +++----
 .../unord.map.modifiers/insert_or_assign.pass.cpp          | 7 +++----
 .../unord.map/unord.map.modifiers/insert_range.pass.cpp    | 7 +++----
 .../unord.map/unord.map.modifiers/insert_rvalue.pass.cpp   | 7 +++----
 .../unord/unord.map/unord.map.modifiers/merge.pass.cpp     | 7 +++----
 .../unord.map/unord.map.modifiers/try.emplace.pass.cpp     | 7 +++----
 .../unord/unord.map/unord.map.swap/db_swap_1.pass.cpp      | 7 +++----
 .../unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp  | 7 +++----
 .../unord.map/unord.map.swap/swap_non_member.pass.cpp      | 7 +++----
 .../unord/unord.multimap/allocator_mismatch.fail.cpp       | 7 +++----
 test/std/containers/unord/unord.multimap/bucket.pass.cpp   | 7 +++----
 .../containers/unord/unord.multimap/bucket_count.pass.cpp  | 7 +++----
 .../containers/unord/unord.multimap/bucket_size.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.multimap/count.pass.cpp    | 7 +++----
 .../unord/unord.multimap/db_iterators_7.pass.cpp           | 7 +++----
 .../unord/unord.multimap/db_iterators_8.pass.cpp           | 7 +++----
 .../unord/unord.multimap/db_local_iterators_7.pass.cpp     | 7 +++----
 .../unord/unord.multimap/db_local_iterators_8.pass.cpp     | 7 +++----
 test/std/containers/unord/unord.multimap/empty.fail.cpp    | 7 +++----
 test/std/containers/unord/unord.multimap/empty.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.multimap/eq.pass.cpp       | 7 +++----
 .../unord/unord.multimap/equal_range_const.pass.cpp        | 7 +++----
 .../unord/unord.multimap/equal_range_non_const.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.multimap/erase_if.pass.cpp | 7 +++----
 .../containers/unord/unord.multimap/find_const.pass.cpp    | 7 +++----
 .../unord/unord.multimap/find_non_const.pass.cpp           | 7 +++----
 .../containers/unord/unord.multimap/incomplete.pass.cpp    | 7 +++----
 .../std/containers/unord/unord.multimap/iterators.fail.cpp | 7 +++----
 .../std/containers/unord/unord.multimap/iterators.pass.cpp | 7 +++----
 .../containers/unord/unord.multimap/load_factor.pass.cpp   | 7 +++----
 .../unord/unord.multimap/local_iterators.fail.cpp          | 7 +++----
 .../unord/unord.multimap/local_iterators.pass.cpp          | 7 +++----
 .../unord/unord.multimap/max_bucket_count.pass.cpp         | 7 +++----
 .../unord/unord.multimap/max_load_factor.pass.cpp          | 7 +++----
 test/std/containers/unord/unord.multimap/max_size.pass.cpp | 7 +++----
 test/std/containers/unord/unord.multimap/rehash.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.multimap/reserve.pass.cpp  | 7 +++----
 test/std/containers/unord/unord.multimap/scary.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.multimap/size.pass.cpp     | 7 +++----
 .../containers/unord/unord.multimap/swap_member.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.multimap/types.pass.cpp    | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/allocator.pass.cpp | 7 +++----
 .../unord.multimap.cnstr/assign_copy.pass.cpp              | 7 +++----
 .../unord.multimap.cnstr/assign_init.pass.cpp              | 7 +++----
 .../unord.multimap.cnstr/assign_move.pass.cpp              | 7 +++----
 .../compare_copy_constructible.fail.cpp                    | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/copy.pass.cpp      | 7 +++----
 .../unord.multimap.cnstr/copy_alloc.pass.cpp               | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/default.pass.cpp   | 7 +++----
 .../unord.multimap.cnstr/default_noexcept.pass.cpp         | 7 +++----
 .../unord.multimap.cnstr/dtor_noexcept.pass.cpp            | 7 +++----
 .../unord.multimap.cnstr/hash_copy_constructible.fail.cpp  | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/init.pass.cpp      | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/init_size.pass.cpp | 7 +++----
 .../unord.multimap.cnstr/init_size_hash.pass.cpp           | 7 +++----
 .../unord.multimap.cnstr/init_size_hash_equal.pass.cpp     | 7 +++----
 .../init_size_hash_equal_allocator.pass.cpp                | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/move.pass.cpp      | 7 +++----
 .../unord.multimap.cnstr/move_alloc.pass.cpp               | 7 +++----
 .../unord.multimap.cnstr/move_assign_noexcept.pass.cpp     | 7 +++----
 .../unord.multimap.cnstr/move_noexcept.pass.cpp            | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/range.pass.cpp     | 7 +++----
 .../unord.multimap.cnstr/range_size.pass.cpp               | 7 +++----
 .../unord.multimap.cnstr/range_size_hash.pass.cpp          | 7 +++----
 .../unord.multimap.cnstr/range_size_hash_equal.pass.cpp    | 7 +++----
 .../range_size_hash_equal_allocator.pass.cpp               | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/size.fail.cpp      | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/size.pass.cpp      | 7 +++----
 .../unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp | 7 +++----
 .../unord.multimap.cnstr/size_hash_equal.pass.cpp          | 7 +++----
 .../size_hash_equal_allocator.pass.cpp                     | 7 +++----
 .../unord.multimap/unord.multimap.modifiers/clear.pass.cpp | 7 +++----
 .../unord.multimap.modifiers/emplace.pass.cpp              | 7 +++----
 .../unord.multimap.modifiers/emplace_hint.pass.cpp         | 7 +++----
 .../unord.multimap.modifiers/erase_const_iter.pass.cpp     | 7 +++----
 .../unord.multimap.modifiers/erase_iter_db1.pass.cpp       | 7 +++----
 .../unord.multimap.modifiers/erase_iter_db2.pass.cpp       | 7 +++----
 .../unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp  | 7 +++----
 .../unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp  | 7 +++----
 .../unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp  | 7 +++----
 .../unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp  | 7 +++----
 .../unord.multimap.modifiers/erase_key.pass.cpp            | 7 +++----
 .../unord.multimap.modifiers/erase_range.pass.cpp          | 7 +++----
 .../unord.multimap.modifiers/extract_iterator.pass.cpp     | 7 +++----
 .../unord.multimap.modifiers/extract_key.pass.cpp          | 7 +++----
 .../insert_allocator_requirements.pass.cpp                 | 7 +++----
 .../unord.multimap.modifiers/insert_const_lvalue.pass.cpp  | 7 +++----
 .../insert_hint_const_lvalue.pass.cpp                      | 7 +++----
 .../unord.multimap.modifiers/insert_hint_rvalue.pass.cpp   | 7 +++----
 .../unord.multimap.modifiers/insert_init.pass.cpp          | 7 +++----
 .../unord.multimap.modifiers/insert_node_type.pass.cpp     | 7 +++----
 .../insert_node_type_hint.pass.cpp                         | 7 +++----
 .../unord.multimap.modifiers/insert_range.pass.cpp         | 7 +++----
 .../unord.multimap.modifiers/insert_rvalue.pass.cpp        | 7 +++----
 .../unord.multimap/unord.multimap.modifiers/merge.pass.cpp | 7 +++----
 .../unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp  | 7 +++----
 .../unord.multimap.swap/swap_noexcept.pass.cpp             | 7 +++----
 .../unord.multimap.swap/swap_non_member.pass.cpp           | 7 +++----
 .../unord/unord.multiset/allocator_mismatch.fail.cpp       | 7 +++----
 test/std/containers/unord/unord.multiset/bucket.pass.cpp   | 7 +++----
 .../containers/unord/unord.multiset/bucket_count.pass.cpp  | 7 +++----
 .../containers/unord/unord.multiset/bucket_size.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.multiset/clear.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.multiset/count.pass.cpp    | 7 +++----
 .../unord/unord.multiset/db_iterators_7.pass.cpp           | 7 +++----
 .../unord/unord.multiset/db_iterators_8.pass.cpp           | 7 +++----
 .../unord/unord.multiset/db_local_iterators_7.pass.cpp     | 7 +++----
 .../unord/unord.multiset/db_local_iterators_8.pass.cpp     | 7 +++----
 test/std/containers/unord/unord.multiset/emplace.pass.cpp  | 7 +++----
 .../containers/unord/unord.multiset/emplace_hint.pass.cpp  | 7 +++----
 test/std/containers/unord/unord.multiset/empty.fail.cpp    | 7 +++----
 test/std/containers/unord/unord.multiset/empty.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.multiset/eq.pass.cpp       | 7 +++----
 .../unord/unord.multiset/equal_range_const.pass.cpp        | 7 +++----
 .../unord/unord.multiset/equal_range_non_const.pass.cpp    | 7 +++----
 .../unord/unord.multiset/erase_const_iter.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.multiset/erase_if.pass.cpp | 7 +++----
 .../unord/unord.multiset/erase_iter_db1.pass.cpp           | 7 +++----
 .../unord/unord.multiset/erase_iter_db2.pass.cpp           | 7 +++----
 .../unord/unord.multiset/erase_iter_iter_db1.pass.cpp      | 7 +++----
 .../unord/unord.multiset/erase_iter_iter_db2.pass.cpp      | 7 +++----
 .../unord/unord.multiset/erase_iter_iter_db3.pass.cpp      | 7 +++----
 .../unord/unord.multiset/erase_iter_iter_db4.pass.cpp      | 7 +++----
 .../std/containers/unord/unord.multiset/erase_key.pass.cpp | 7 +++----
 .../containers/unord/unord.multiset/erase_range.pass.cpp   | 7 +++----
 .../unord/unord.multiset/extract_iterator.pass.cpp         | 7 +++----
 .../containers/unord/unord.multiset/extract_key.pass.cpp   | 7 +++----
 .../containers/unord/unord.multiset/find_const.pass.cpp    | 7 +++----
 .../unord/unord.multiset/find_non_const.pass.cpp           | 7 +++----
 .../containers/unord/unord.multiset/incomplete.pass.cpp    | 7 +++----
 .../unord/unord.multiset/insert_const_lvalue.pass.cpp      | 7 +++----
 .../insert_emplace_allocator_requirements.pass.cpp         | 7 +++----
 .../unord/unord.multiset/insert_hint_const_lvalue.pass.cpp | 7 +++----
 .../unord/unord.multiset/insert_hint_rvalue.pass.cpp       | 7 +++----
 .../containers/unord/unord.multiset/insert_init.pass.cpp   | 7 +++----
 .../unord/unord.multiset/insert_node_type.pass.cpp         | 7 +++----
 .../unord/unord.multiset/insert_node_type_hint.pass.cpp    | 7 +++----
 .../containers/unord/unord.multiset/insert_range.pass.cpp  | 7 +++----
 .../containers/unord/unord.multiset/insert_rvalue.pass.cpp | 7 +++----
 .../std/containers/unord/unord.multiset/iterators.fail.cpp | 7 +++----
 .../std/containers/unord/unord.multiset/iterators.pass.cpp | 7 +++----
 .../containers/unord/unord.multiset/load_factor.pass.cpp   | 7 +++----
 .../unord/unord.multiset/local_iterators.fail.cpp          | 7 +++----
 .../unord/unord.multiset/local_iterators.pass.cpp          | 7 +++----
 .../unord/unord.multiset/max_bucket_count.pass.cpp         | 7 +++----
 .../unord/unord.multiset/max_load_factor.pass.cpp          | 7 +++----
 test/std/containers/unord/unord.multiset/max_size.pass.cpp | 7 +++----
 test/std/containers/unord/unord.multiset/merge.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.multiset/rehash.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.multiset/reserve.pass.cpp  | 7 +++----
 test/std/containers/unord/unord.multiset/scary.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.multiset/size.pass.cpp     | 7 +++----
 .../containers/unord/unord.multiset/swap_member.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.multiset/types.pass.cpp    | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/allocator.pass.cpp | 7 +++----
 .../unord.multiset.cnstr/assign_copy.pass.cpp              | 7 +++----
 .../unord.multiset.cnstr/assign_init.pass.cpp              | 7 +++----
 .../unord.multiset.cnstr/assign_move.pass.cpp              | 7 +++----
 .../compare_copy_constructible.fail.cpp                    | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/copy.pass.cpp      | 7 +++----
 .../unord.multiset.cnstr/copy_alloc.pass.cpp               | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/default.pass.cpp   | 7 +++----
 .../unord.multiset.cnstr/default_noexcept.pass.cpp         | 7 +++----
 .../unord.multiset.cnstr/dtor_noexcept.pass.cpp            | 7 +++----
 .../unord.multiset.cnstr/hash_copy_constructible.fail.cpp  | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/init.pass.cpp      | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/init_size.pass.cpp | 7 +++----
 .../unord.multiset.cnstr/init_size_hash.pass.cpp           | 7 +++----
 .../unord.multiset.cnstr/init_size_hash_equal.pass.cpp     | 7 +++----
 .../init_size_hash_equal_allocator.pass.cpp                | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/move.pass.cpp      | 7 +++----
 .../unord.multiset.cnstr/move_alloc.pass.cpp               | 7 +++----
 .../unord.multiset.cnstr/move_assign_noexcept.pass.cpp     | 7 +++----
 .../unord.multiset.cnstr/move_noexcept.pass.cpp            | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/range.pass.cpp     | 7 +++----
 .../unord.multiset.cnstr/range_size.pass.cpp               | 7 +++----
 .../unord.multiset.cnstr/range_size_hash.pass.cpp          | 7 +++----
 .../unord.multiset.cnstr/range_size_hash_equal.pass.cpp    | 7 +++----
 .../range_size_hash_equal_allocator.pass.cpp               | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/size.fail.cpp      | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/size.pass.cpp      | 7 +++----
 .../unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp | 7 +++----
 .../unord.multiset.cnstr/size_hash_equal.pass.cpp          | 7 +++----
 .../size_hash_equal_allocator.pass.cpp                     | 7 +++----
 .../unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp  | 7 +++----
 .../unord.multiset.swap/swap_noexcept.pass.cpp             | 7 +++----
 .../unord.multiset.swap/swap_non_member.pass.cpp           | 7 +++----
 .../containers/unord/unord.set/allocator_mismatch.fail.cpp | 7 +++----
 test/std/containers/unord/unord.set/bucket.pass.cpp        | 7 +++----
 test/std/containers/unord/unord.set/bucket_count.pass.cpp  | 7 +++----
 test/std/containers/unord/unord.set/bucket_size.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.set/clear.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.set/count.pass.cpp         | 7 +++----
 .../std/containers/unord/unord.set/db_iterators_7.pass.cpp | 7 +++----
 .../std/containers/unord/unord.set/db_iterators_8.pass.cpp | 7 +++----
 .../unord/unord.set/db_local_iterators_7.pass.cpp          | 7 +++----
 .../unord/unord.set/db_local_iterators_8.pass.cpp          | 7 +++----
 test/std/containers/unord/unord.set/emplace.pass.cpp       | 7 +++----
 test/std/containers/unord/unord.set/emplace_hint.pass.cpp  | 7 +++----
 test/std/containers/unord/unord.set/empty.fail.cpp         | 7 +++----
 test/std/containers/unord/unord.set/empty.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.set/eq.pass.cpp            | 7 +++----
 .../containers/unord/unord.set/equal_range_const.pass.cpp  | 7 +++----
 .../unord/unord.set/equal_range_non_const.pass.cpp         | 7 +++----
 .../containers/unord/unord.set/erase_const_iter.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.set/erase_if.pass.cpp      | 7 +++----
 .../std/containers/unord/unord.set/erase_iter_db1.pass.cpp | 7 +++----
 .../std/containers/unord/unord.set/erase_iter_db2.pass.cpp | 7 +++----
 .../unord/unord.set/erase_iter_iter_db1.pass.cpp           | 7 +++----
 .../unord/unord.set/erase_iter_iter_db2.pass.cpp           | 7 +++----
 .../unord/unord.set/erase_iter_iter_db3.pass.cpp           | 7 +++----
 .../unord/unord.set/erase_iter_iter_db4.pass.cpp           | 7 +++----
 test/std/containers/unord/unord.set/erase_key.pass.cpp     | 7 +++----
 test/std/containers/unord/unord.set/erase_range.pass.cpp   | 7 +++----
 .../containers/unord/unord.set/extract_iterator.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.set/extract_key.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.set/find_const.pass.cpp    | 7 +++----
 .../std/containers/unord/unord.set/find_non_const.pass.cpp | 7 +++----
 test/std/containers/unord/unord.set/incomplete.pass.cpp    | 7 +++----
 .../insert_and_emplace_allocator_requirements.pass.cpp     | 7 +++----
 .../unord/unord.set/insert_const_lvalue.pass.cpp           | 7 +++----
 .../unord/unord.set/insert_hint_const_lvalue.pass.cpp      | 7 +++----
 .../containers/unord/unord.set/insert_hint_rvalue.pass.cpp | 7 +++----
 test/std/containers/unord/unord.set/insert_init.pass.cpp   | 7 +++----
 .../containers/unord/unord.set/insert_node_type.pass.cpp   | 7 +++----
 .../unord/unord.set/insert_node_type_hint.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.set/insert_range.pass.cpp  | 7 +++----
 test/std/containers/unord/unord.set/insert_rvalue.pass.cpp | 7 +++----
 test/std/containers/unord/unord.set/iterators.fail.cpp     | 7 +++----
 test/std/containers/unord/unord.set/iterators.pass.cpp     | 7 +++----
 test/std/containers/unord/unord.set/load_factor.pass.cpp   | 7 +++----
 .../containers/unord/unord.set/local_iterators.fail.cpp    | 7 +++----
 .../containers/unord/unord.set/local_iterators.pass.cpp    | 7 +++----
 .../containers/unord/unord.set/max_bucket_count.pass.cpp   | 7 +++----
 .../containers/unord/unord.set/max_load_factor.pass.cpp    | 7 +++----
 test/std/containers/unord/unord.set/max_size.pass.cpp      | 7 +++----
 test/std/containers/unord/unord.set/merge.pass.cpp         | 7 +++----
 test/std/containers/unord/unord.set/rehash.pass.cpp        | 7 +++----
 test/std/containers/unord/unord.set/reserve.pass.cpp       | 7 +++----
 test/std/containers/unord/unord.set/size.pass.cpp          | 7 +++----
 test/std/containers/unord/unord.set/swap_member.pass.cpp   | 7 +++----
 test/std/containers/unord/unord.set/types.pass.cpp         | 7 +++----
 .../unord/unord.set/unord.set.cnstr/allocator.pass.cpp     | 7 +++----
 .../unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp   | 7 +++----
 .../unord/unord.set/unord.set.cnstr/assign_init.pass.cpp   | 7 +++----
 .../unord/unord.set/unord.set.cnstr/assign_move.pass.cpp   | 7 +++----
 .../unord.set.cnstr/compare_copy_constructible.fail.cpp    | 7 +++----
 .../unord/unord.set/unord.set.cnstr/copy.pass.cpp          | 7 +++----
 .../unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp    | 7 +++----
 .../unord/unord.set/unord.set.cnstr/default.pass.cpp       | 7 +++----
 .../unord.set/unord.set.cnstr/default_noexcept.pass.cpp    | 7 +++----
 .../unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp | 7 +++----
 .../unord.set.cnstr/hash_copy_constructible.fail.cpp       | 7 +++----
 .../unord/unord.set/unord.set.cnstr/init.pass.cpp          | 7 +++----
 .../unord/unord.set/unord.set.cnstr/init_size.pass.cpp     | 7 +++----
 .../unord.set/unord.set.cnstr/init_size_hash.pass.cpp      | 7 +++----
 .../unord.set.cnstr/init_size_hash_equal.pass.cpp          | 7 +++----
 .../init_size_hash_equal_allocator.pass.cpp                | 7 +++----
 .../unord/unord.set/unord.set.cnstr/move.pass.cpp          | 7 +++----
 .../unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp    | 7 +++----
 .../unord.set.cnstr/move_assign_noexcept.pass.cpp          | 7 +++----
 .../unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp | 7 +++----
 .../unord/unord.set/unord.set.cnstr/range.pass.cpp         | 7 +++----
 .../unord/unord.set/unord.set.cnstr/range_size.pass.cpp    | 7 +++----
 .../unord.set/unord.set.cnstr/range_size_hash.pass.cpp     | 7 +++----
 .../unord.set.cnstr/range_size_hash_equal.pass.cpp         | 7 +++----
 .../range_size_hash_equal_allocator.pass.cpp               | 7 +++----
 .../unord/unord.set/unord.set.cnstr/size.fail.cpp          | 7 +++----
 .../unord/unord.set/unord.set.cnstr/size.pass.cpp          | 7 +++----
 .../unord/unord.set/unord.set.cnstr/size_hash.pass.cpp     | 7 +++----
 .../unord.set/unord.set.cnstr/size_hash_equal.pass.cpp     | 7 +++----
 .../unord.set.cnstr/size_hash_equal_allocator.pass.cpp     | 7 +++----
 .../unord/unord.set/unord.set.swap/db_swap_1.pass.cpp      | 7 +++----
 .../unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp  | 7 +++----
 .../unord.set/unord.set.swap/swap_non_member.pass.cpp      | 7 +++----
 test/std/containers/views/span.cons/array.fail.cpp         | 7 +++----
 test/std/containers/views/span.cons/array.pass.cpp         | 7 +++----
 test/std/containers/views/span.cons/assign.pass.cpp        | 7 +++----
 test/std/containers/views/span.cons/container.fail.cpp     | 7 +++----
 test/std/containers/views/span.cons/container.pass.cpp     | 7 +++----
 test/std/containers/views/span.cons/copy.pass.cpp          | 7 +++----
 test/std/containers/views/span.cons/deduct.pass.cpp        | 7 +++----
 test/std/containers/views/span.cons/default.fail.cpp       | 7 +++----
 test/std/containers/views/span.cons/default.pass.cpp       | 7 +++----
 test/std/containers/views/span.cons/ptr_len.fail.cpp       | 7 +++----
 test/std/containers/views/span.cons/ptr_len.pass.cpp       | 7 +++----
 test/std/containers/views/span.cons/ptr_ptr.fail.cpp       | 7 +++----
 test/std/containers/views/span.cons/ptr_ptr.pass.cpp       | 7 +++----
 test/std/containers/views/span.cons/span.fail.cpp          | 7 +++----
 test/std/containers/views/span.cons/span.pass.cpp          | 7 +++----
 test/std/containers/views/span.cons/stdarray.pass.cpp      | 7 +++----
 test/std/containers/views/span.elem/data.pass.cpp          | 7 +++----
 test/std/containers/views/span.elem/op_idx.pass.cpp        | 7 +++----
 test/std/containers/views/span.iterators/begin.pass.cpp    | 7 +++----
 test/std/containers/views/span.iterators/end.pass.cpp      | 7 +++----
 test/std/containers/views/span.iterators/rbegin.pass.cpp   | 7 +++----
 test/std/containers/views/span.iterators/rend.pass.cpp     | 7 +++----
 test/std/containers/views/span.objectrep/as_bytes.pass.cpp | 7 +++----
 .../views/span.objectrep/as_writeable_bytes.fail.cpp       | 7 +++----
 .../views/span.objectrep/as_writeable_bytes.pass.cpp       | 7 +++----
 test/std/containers/views/span.obs/empty.pass.cpp          | 7 +++----
 test/std/containers/views/span.obs/size.pass.cpp           | 7 +++----
 test/std/containers/views/span.obs/size_bytes.pass.cpp     | 7 +++----
 test/std/containers/views/span.sub/first.pass.cpp          | 7 +++----
 test/std/containers/views/span.sub/last.pass.cpp           | 7 +++----
 test/std/containers/views/span.sub/subspan.pass.cpp        | 7 +++----
 test/std/containers/views/types.pass.cpp                   | 7 +++----
 test/std/depr/depr.auto.ptr/auto.ptr/A.h                   | 7 +++----
 test/std/depr/depr.auto.ptr/auto.ptr/AB.h                  | 7 +++----
 .../auto.ptr/auto.ptr.cons/assignment.fail.cpp             | 7 +++----
 .../auto.ptr/auto.ptr.cons/assignment.pass.cpp             | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp  | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp  | 7 +++----
 .../auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp     | 7 +++----
 .../auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp     | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp     | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp     | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp  | 7 +++----
 .../auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp        | 7 +++----
 .../auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp       | 7 +++----
 .../auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp    | 7 +++----
 .../auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp         | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp | 7 +++----
 .../auto.ptr/auto.ptr.members/release.pass.cpp             | 7 +++----
 .../depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp | 7 +++----
 test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp | 7 +++----
 test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp         | 7 +++----
 test/std/depr/depr.c.headers/assert_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/ciso646.pass.cpp              | 7 +++----
 test/std/depr/depr.c.headers/complex.h.pass.cpp            | 7 +++----
 test/std/depr/depr.c.headers/ctype_h.pass.cpp              | 7 +++----
 test/std/depr/depr.c.headers/errno_h.pass.cpp              | 7 +++----
 test/std/depr/depr.c.headers/fenv_h.pass.cpp               | 7 +++----
 test/std/depr/depr.c.headers/float_h.pass.cpp              | 7 +++----
 test/std/depr/depr.c.headers/inttypes_h.pass.cpp           | 7 +++----
 test/std/depr/depr.c.headers/iso646_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/limits_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/locale_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/math_h.pass.cpp               | 7 +++----
 test/std/depr/depr.c.headers/setjmp_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/signal_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/stdarg_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/stdbool_h.pass.cpp            | 7 +++----
 test/std/depr/depr.c.headers/stddef_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/stdint_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/stdio_h.pass.cpp              | 7 +++----
 test/std/depr/depr.c.headers/stdlib_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/string_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/tgmath_h.pass.cpp             | 7 +++----
 test/std/depr/depr.c.headers/time_h.pass.cpp               | 7 +++----
 test/std/depr/depr.c.headers/uchar_h.pass.cpp              | 7 +++----
 test/std/depr/depr.c.headers/wchar_h.pass.cpp              | 7 +++----
 test/std/depr/depr.c.headers/wctype_h.pass.cpp             | 7 +++----
 .../pointer_to_binary_function.cxx1z.fail.cpp              | 7 +++----
 .../pointer_to_binary_function.pass.cpp                    | 7 +++----
 .../pointer_to_unary_function.cxx1z.fail.cpp               | 7 +++----
 .../pointer_to_unary_function.pass.cpp                     | 7 +++----
 .../depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp | 7 +++----
 .../depr.function.pointer.adaptors/ptr_fun1.pass.cpp       | 7 +++----
 .../depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp | 7 +++----
 .../depr.function.pointer.adaptors/ptr_fun2.pass.cpp       | 7 +++----
 .../const_mem_fun.cxx1z.fail.cpp                           | 7 +++----
 .../depr.member.pointer.adaptors/const_mem_fun.pass.cpp    | 7 +++----
 .../const_mem_fun1.cxx1z.fail.cpp                          | 7 +++----
 .../depr.member.pointer.adaptors/const_mem_fun1.pass.cpp   | 7 +++----
 .../const_mem_fun1_ref_t.cxx1z.fail.cpp                    | 7 +++----
 .../const_mem_fun1_ref_t.pass.cpp                          | 7 +++----
 .../const_mem_fun1_t.cxx1z.fail.cpp                        | 7 +++----
 .../depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp | 7 +++----
 .../const_mem_fun_ref.cxx1z.fail.cpp                       | 7 +++----
 .../const_mem_fun_ref.pass.cpp                             | 7 +++----
 .../const_mem_fun_ref1.cxx1z.fail.cpp                      | 7 +++----
 .../const_mem_fun_ref1.pass.cpp                            | 7 +++----
 .../const_mem_fun_ref_t.cxx1z.fail.cpp                     | 7 +++----
 .../const_mem_fun_ref_t.pass.cpp                           | 7 +++----
 .../const_mem_fun_t.cxx1z.fail.cpp                         | 7 +++----
 .../depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp  | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp    | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun.pass.cpp          | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp   | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun1.pass.cpp         | 7 +++----
 .../mem_fun1_ref_t.cxx1z.fail.cpp                          | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp   | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun1_t.pass.cpp       | 7 +++----
 .../mem_fun_ref.cxx1z.fail.cpp                             | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun_ref.pass.cpp      | 7 +++----
 .../mem_fun_ref1.cxx1z.fail.cpp                            | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp     | 7 +++----
 .../mem_fun_ref_t.cxx1z.fail.cpp                           | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp    | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp  | 7 +++----
 .../depr.member.pointer.adaptors/mem_fun_t.pass.cpp        | 7 +++----
 .../depr.adaptors/nothing_to_do.pass.cpp                   | 7 +++----
 .../depr.base/binary_function.pass.cpp                     | 7 +++----
 .../depr.base/unary_function.pass.cpp                      | 7 +++----
 test/std/depr/depr.function.objects/nothing_to_do.pass.cpp | 7 +++----
 test/std/depr/depr.ios.members/io_state.pass.cpp           | 7 +++----
 test/std/depr/depr.ios.members/open_mode.pass.cpp          | 7 +++----
 test/std/depr/depr.ios.members/seek_dir.pass.cpp           | 7 +++----
 test/std/depr/depr.ios.members/streamoff.pass.cpp          | 7 +++----
 test/std/depr/depr.ios.members/streampos.pass.cpp          | 7 +++----
 .../depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp       | 7 +++----
 .../depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp    | 7 +++----
 .../depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp       | 7 +++----
 .../depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp    | 7 +++----
 .../depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp   | 7 +++----
 .../depr.lib.binder.1st/binder1st.pass.cpp                 | 7 +++----
 .../depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp   | 7 +++----
 .../depr.lib.binder.2nd/binder2nd.pass.cpp                 | 7 +++----
 test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp      | 7 +++----
 test/std/depr/depr.lib.binders/test_func.h                 | 7 +++----
 .../depr.istrstream/depr.istrstream.cons/ccp.pass.cpp      | 7 +++----
 .../depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp | 7 +++----
 .../depr.istrstream/depr.istrstream.cons/cp.pass.cpp       | 7 +++----
 .../depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp  | 7 +++----
 .../depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp | 7 +++----
 .../depr.istrstream/depr.istrstream.members/str.pass.cpp   | 7 +++----
 .../depr.str.strstreams/depr.istrstream/types.pass.cpp     | 7 +++----
 .../depr.ostrstream.cons/cp_size_mode.pass.cpp             | 7 +++----
 .../depr.ostrstream/depr.ostrstream.cons/default.pass.cpp  | 7 +++----
 .../depr.ostrstream.members/freeze.pass.cpp                | 7 +++----
 .../depr.ostrstream.members/pcount.pass.cpp                | 7 +++----
 .../depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp | 7 +++----
 .../depr.ostrstream/depr.ostrstream.members/str.pass.cpp   | 7 +++----
 .../depr.str.strstreams/depr.ostrstream/types.pass.cpp     | 7 +++----
 .../depr.strstream.cons/cp_size_mode.pass.cpp              | 7 +++----
 .../depr.strstream/depr.strstream.cons/default.pass.cpp    | 7 +++----
 .../depr.strstream/depr.strstream.dest/rdbuf.pass.cpp      | 7 +++----
 .../depr.strstream/depr.strstream.oper/freeze.pass.cpp     | 7 +++----
 .../depr.strstream/depr.strstream.oper/pcount.pass.cpp     | 7 +++----
 .../depr.strstream/depr.strstream.oper/str.pass.cpp        | 7 +++----
 .../depr/depr.str.strstreams/depr.strstream/types.pass.cpp | 7 +++----
 .../depr.strstreambuf.cons/ccp_size.pass.cpp               | 7 +++----
 .../depr.strstreambuf.cons/cp_size_cp.pass.cpp             | 7 +++----
 .../depr.strstreambuf.cons/cscp_size.pass.cpp              | 7 +++----
 .../depr.strstreambuf.cons/cucp_size.pass.cpp              | 7 +++----
 .../depr.strstreambuf.cons/custom_alloc.pass.cpp           | 7 +++----
 .../depr.strstreambuf.cons/default.pass.cpp                | 7 +++----
 .../depr.strstreambuf.cons/scp_size_scp.pass.cpp           | 7 +++----
 .../depr.strstreambuf.cons/ucp_size_ucp.pass.cpp           | 7 +++----
 .../depr.strstreambuf.members/freeze.pass.cpp              | 7 +++----
 .../depr.strstreambuf.members/overflow.pass.cpp            | 7 +++----
 .../depr.strstreambuf.members/pcount.pass.cpp              | 7 +++----
 .../depr.strstreambuf.members/str.pass.cpp                 | 7 +++----
 .../depr.strstreambuf.virtuals/overflow.pass.cpp           | 7 +++----
 .../depr.strstreambuf.virtuals/pbackfail.pass.cpp          | 7 +++----
 .../depr.strstreambuf.virtuals/seekoff.pass.cpp            | 7 +++----
 .../depr.strstreambuf.virtuals/seekpos.pass.cpp            | 7 +++----
 .../depr.strstreambuf.virtuals/setbuf.pass.cpp             | 7 +++----
 .../depr.strstreambuf.virtuals/underflow.pass.cpp          | 7 +++----
 .../depr.str.strstreams/depr.strstreambuf/types.pass.cpp   | 7 +++----
 test/std/depr/exception.unexpected/nothing_to_do.pass.cpp  | 7 +++----
 .../set.unexpected/get_unexpected.pass.cpp                 | 7 +++----
 .../set.unexpected/set_unexpected.pass.cpp                 | 7 +++----
 .../unexpected.handler/unexpected_handler.pass.cpp         | 7 +++----
 .../exception.unexpected/unexpected/unexpected.pass.cpp    | 7 +++----
 test/std/depr/nothing_to_do.pass.cpp                       | 7 +++----
 test/std/diagnostics/assertions/cassert.pass.cpp           | 7 +++----
 .../diagnostics/diagnostics.general/nothing_to_do.pass.cpp | 7 +++----
 test/std/diagnostics/errno/cerrno.pass.cpp                 | 7 +++----
 test/std/diagnostics/nothing_to_do.pass.cpp                | 7 +++----
 .../std.exceptions/domain.error/domain_error.pass.cpp      | 7 +++----
 .../invalid.argument/invalid_argument.pass.cpp             | 7 +++----
 .../std.exceptions/length.error/length_error.pass.cpp      | 7 +++----
 .../std.exceptions/logic.error/logic_error.pass.cpp        | 7 +++----
 .../std.exceptions/out.of.range/out_of_range.pass.cpp      | 7 +++----
 .../std.exceptions/overflow.error/overflow_error.pass.cpp  | 7 +++----
 .../std.exceptions/range.error/range_error.pass.cpp        | 7 +++----
 .../std.exceptions/runtime.error/runtime_error.pass.cpp    | 7 +++----
 .../underflow.error/underflow_error.pass.cpp               | 7 +++----
 test/std/diagnostics/syserr/errc.pass.cpp                  | 7 +++----
 test/std/diagnostics/syserr/is_error_code_enum.pass.cpp    | 7 +++----
 .../diagnostics/syserr/is_error_condition_enum.pass.cpp    | 7 +++----
 .../syserr.compare/eq_error_code_error_code.pass.cpp       | 7 +++----
 .../syserr/syserr.errcat/nothing_to_do.pass.cpp            | 7 +++----
 .../syserr.errcat/syserr.errcat.derived/message.pass.cpp   | 7 +++----
 .../syserr.errcat.nonvirtuals/default_ctor.pass.cpp        | 7 +++----
 .../syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp    | 7 +++----
 .../syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp    | 7 +++----
 .../syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp   | 7 +++----
 .../syserr.errcat.objects/generic_category.pass.cpp        | 7 +++----
 .../syserr.errcat.objects/system_category.pass.cpp         | 7 +++----
 .../syserr.errcat.overview/error_category.pass.cpp         | 7 +++----
 .../default_error_condition.pass.cpp                       | 7 +++----
 .../equivalent_error_code_int.pass.cpp                     | 7 +++----
 .../equivalent_int_error_condition.pass.cpp                | 7 +++----
 .../syserr/syserr.errcode/nothing_to_do.pass.cpp           | 7 +++----
 .../syserr.errcode.constructors/ErrorCodeEnum.pass.cpp     | 7 +++----
 .../syserr.errcode.constructors/default.pass.cpp           | 7 +++----
 .../int_error_category.pass.cpp                            | 7 +++----
 .../syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp        | 7 +++----
 .../syserr.errcode.modifiers/assign.pass.cpp               | 7 +++----
 .../syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp | 7 +++----
 .../syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp   | 7 +++----
 .../syserr.errcode.nonmembers/make_error_code.pass.cpp     | 7 +++----
 .../syserr.errcode.nonmembers/stream_inserter.pass.cpp     | 7 +++----
 .../syserr.errcode/syserr.errcode.observers/bool.fail.cpp  | 7 +++----
 .../syserr.errcode/syserr.errcode.observers/bool.pass.cpp  | 7 +++----
 .../syserr.errcode.observers/category.pass.cpp             | 7 +++----
 .../default_error_condition.pass.cpp                       | 7 +++----
 .../syserr.errcode.observers/message.pass.cpp              | 7 +++----
 .../syserr.errcode/syserr.errcode.observers/value.pass.cpp | 7 +++----
 .../syserr.errcode/syserr.errcode.overview/types.pass.cpp  | 7 +++----
 .../syserr/syserr.errcondition/nothing_to_do.pass.cpp      | 7 +++----
 .../ErrorConditionEnum.pass.cpp                            | 7 +++----
 .../syserr.errcondition.constructors/default.pass.cpp      | 7 +++----
 .../int_error_category.pass.cpp                            | 7 +++----
 .../ErrorConditionEnum.pass.cpp                            | 7 +++----
 .../syserr.errcondition.modifiers/assign.pass.cpp          | 7 +++----
 .../syserr.errcondition.modifiers/clear.pass.cpp           | 7 +++----
 .../syserr.errcondition.nonmembers/lt.pass.cpp             | 7 +++----
 .../make_error_condition.pass.cpp                          | 7 +++----
 .../syserr.errcondition.observers/bool.pass.cpp            | 7 +++----
 .../syserr.errcondition.observers/category.pass.cpp        | 7 +++----
 .../syserr.errcondition.observers/message.pass.cpp         | 7 +++----
 .../syserr.errcondition.observers/value.pass.cpp           | 7 +++----
 .../syserr.errcondition.overview/types.pass.cpp            | 7 +++----
 .../diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp   | 7 +++----
 .../std/diagnostics/syserr/syserr.hash/error_code.pass.cpp | 7 +++----
 .../syserr/syserr.hash/error_condition.pass.cpp            | 7 +++----
 .../syserr/syserr.syserr/nothing_to_do.pass.cpp            | 7 +++----
 .../syserr.syserr.members/ctor_error_code.pass.cpp         | 7 +++----
 .../ctor_error_code_const_char_pointer.pass.cpp            | 7 +++----
 .../syserr.syserr.members/ctor_error_code_string.pass.cpp  | 7 +++----
 .../syserr.syserr.members/ctor_int_error_category.pass.cpp | 7 +++----
 .../ctor_int_error_category_const_char_pointer.pass.cpp    | 7 +++----
 .../ctor_int_error_category_string.pass.cpp                | 7 +++----
 .../syserr.syserr.overview/nothing_to_do.pass.cpp          | 7 +++----
 .../std/experimental/algorithms/alg.search/search.pass.cpp | 7 +++----
 .../filesystem/fs.req.macros/feature_macro.pass.cpp        | 7 +++----
 .../filesystem/fs.req.namespace/namespace.pass.cpp         | 7 +++----
 .../func.searchers.boyer_moore/default.pass.cpp            | 7 +++----
 .../func.searchers.boyer_moore/hash.pass.cpp               | 7 +++----
 .../func.searchers.boyer_moore/hash.pred.pass.cpp          | 7 +++----
 .../func.searchers.boyer_moore/pred.pass.cpp               | 7 +++----
 .../func.searchers.boyer_moore_horspool/default.pass.cpp   | 7 +++----
 .../func.searchers.boyer_moore_horspool/hash.pass.cpp      | 7 +++----
 .../func.searchers.boyer_moore_horspool/hash.pred.pass.cpp | 7 +++----
 .../func.searchers.boyer_moore_horspool/pred.pass.cpp      | 7 +++----
 .../func.searchers/func.searchers.default/default.pass.cpp | 7 +++----
 .../func.searchers.default/default.pred.pass.cpp           | 7 +++----
 .../make_default_searcher.pass.cpp                         | 7 +++----
 .../make_default_searcher.pred.pass.cpp                    | 7 +++----
 .../func/func.searchers/nothing_to_do.pass.cpp             | 7 +++----
 .../func/header.functional.synop/includes.pass.cpp         | 7 +++----
 test/std/experimental/func/nothing_to_do.pass.cpp          | 7 +++----
 test/std/experimental/iterator/nothing_to_do.pass.cpp      | 7 +++----
 .../ostream.joiner.cons/ostream_joiner.cons.pass.cpp       | 7 +++----
 .../ostream.joiner.creation/make_ostream_joiner.pass.cpp   | 7 +++----
 .../ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp   | 7 +++----
 .../ostream_joiner.op.postincrement.pass.cpp               | 7 +++----
 .../ostream_joiner.op.pretincrement.pass.cpp               | 7 +++----
 .../ostream.joiner.ops/ostream_joiner.op.star.pass.cpp     | 7 +++----
 .../coroutine.handle.capacity/operator_bool.pass.cpp       | 7 +++----
 .../coroutine.handle.compare/equal_comp.pass.cpp           | 7 +++----
 .../coroutine.handle.compare/less_comp.pass.cpp            | 7 +++----
 .../coroutine.handle.completion/done.pass.cpp              | 7 +++----
 .../coroutine.handle/coroutine.handle.con/assign.pass.cpp  | 7 +++----
 .../coroutine.handle.con/construct.pass.cpp                | 7 +++----
 .../coroutine.handle.export/address.pass.cpp               | 7 +++----
 .../coroutine.handle.export/from_address.fail.cpp          | 7 +++----
 .../coroutine.handle.export/from_address.pass.cpp          | 7 +++----
 .../coroutine.handle/coroutine.handle.hash/hash.pass.cpp   | 7 +++----
 .../coroutine.handle.noop/noop_coroutine.pass.cpp          | 7 +++----
 .../coroutine.handle.prom/promise.pass.cpp                 | 7 +++----
 .../coroutine.handle.resumption/destroy.pass.cpp           | 7 +++----
 .../coroutine.handle.resumption/resume.pass.cpp            | 7 +++----
 .../coroutine.handle/void_handle.pass.cpp                  | 7 +++----
 .../coroutine.traits/promise_type.pass.cpp                 | 7 +++----
 .../coroutine.trivial.awaitables/suspend_always.pass.cpp   | 7 +++----
 .../coroutine.trivial.awaitables/suspend_never.pass.cpp    | 7 +++----
 .../support.coroutines/end.to.end/await_result.pass.cpp    | 7 +++----
 .../end.to.end/bool_await_suspend.pass.cpp                 | 7 +++----
 .../support.coroutines/end.to.end/expected.pass.cpp        | 7 +++----
 .../support.coroutines/end.to.end/fullexpr-dtor.pass.cpp   | 7 +++----
 .../support.coroutines/end.to.end/generator.pass.cpp       | 7 +++----
 .../support.coroutines/end.to.end/go.pass.cpp              | 7 +++----
 .../support.coroutines/end.to.end/multishot_func.pass.cpp  | 7 +++----
 .../support.coroutines/end.to.end/oneshot_func.pass.cpp    | 7 +++----
 .../language.support/support.coroutines/includes.pass.cpp  | 7 +++----
 .../memory.polymorphic.allocator.ctor/assign.pass.cpp      | 7 +++----
 .../memory.polymorphic.allocator.ctor/copy.pass.cpp        | 7 +++----
 .../memory.polymorphic.allocator.ctor/default.pass.cpp     | 7 +++----
 .../memory_resource_convert.pass.cpp                       | 7 +++----
 .../memory.polymorphic.allocator.ctor/other_alloc.pass.cpp | 7 +++----
 .../memory.polymorphic.allocator.eq/equal.pass.cpp         | 7 +++----
 .../memory.polymorphic.allocator.eq/not_equal.pass.cpp     | 7 +++----
 .../memory.polymorphic.allocator.mem/allocate.pass.cpp     | 7 +++----
 .../construct_pair.pass.cpp                                | 7 +++----
 .../construct_pair_const_lvalue_pair.pass.cpp              | 7 +++----
 .../construct_pair_rvalue.pass.cpp                         | 7 +++----
 .../construct_pair_values.pass.cpp                         | 7 +++----
 .../construct_piecewise_pair.pass.cpp                      | 7 +++----
 .../construct_piecewise_pair_evil.pass.cpp                 | 7 +++----
 .../construct_types.pass.cpp                               | 7 +++----
 .../memory.polymorphic.allocator.mem/deallocate.pass.cpp   | 7 +++----
 .../memory.polymorphic.allocator.mem/destroy.pass.cpp      | 7 +++----
 .../memory.polymorphic.allocator.mem/resource.pass.cpp     | 7 +++----
 .../select_on_container_copy_construction.pass.cpp         | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../memory.resource.adaptor.ctor/alloc_copy.pass.cpp       | 7 +++----
 .../memory.resource.adaptor.ctor/alloc_move.pass.cpp       | 7 +++----
 .../memory.resource.adaptor.ctor/default.pass.cpp          | 7 +++----
 .../do_allocate_and_deallocate.pass.cpp                    | 7 +++----
 .../memory.resource.adaptor.mem/do_is_equal.pass.cpp       | 7 +++----
 .../memory.resource.adaptor.overview/overview.pass.cpp     | 7 +++----
 .../memory.resource.aliases/header_deque_synop.pass.cpp    | 7 +++----
 .../header_forward_list_synop.pass.cpp                     | 7 +++----
 .../memory.resource.aliases/header_list_synop.pass.cpp     | 7 +++----
 .../memory.resource.aliases/header_map_synop.pass.cpp      | 7 +++----
 .../memory.resource.aliases/header_regex_synop.pass.cpp    | 7 +++----
 .../memory.resource.aliases/header_set_synop.pass.cpp      | 7 +++----
 .../memory.resource.aliases/header_string_synop.pass.cpp   | 7 +++----
 .../header_unordered_map_synop.pass.cpp                    | 7 +++----
 .../header_unordered_set_synop.pass.cpp                    | 7 +++----
 .../memory.resource.aliases/header_vector_synop.pass.cpp   | 7 +++----
 .../memory.resource.global/default_resource.pass.cpp       | 7 +++----
 .../memory.resource.global/new_delete_resource.pass.cpp    | 7 +++----
 .../memory.resource.global/null_memory_resource.pass.cpp   | 7 +++----
 .../memory/memory.resource.synop/nothing_to_do.pass.cpp    | 7 +++----
 .../experimental/memory/memory.resource/construct.fail.cpp | 7 +++----
 .../memory.resource/memory.resource.eq/equal.pass.cpp      | 7 +++----
 .../memory.resource/memory.resource.eq/not_equal.pass.cpp  | 7 +++----
 .../memory.resource.overview/nothing_to_do.pass.cpp        | 7 +++----
 .../memory.resource.priv/protected_members.fail.cpp        | 7 +++----
 .../memory.resource.public/allocate.pass.cpp               | 7 +++----
 .../memory.resource.public/deallocate.pass.cpp             | 7 +++----
 .../memory.resource/memory.resource.public/dtor.pass.cpp   | 7 +++----
 .../memory.resource.public/is_equal.pass.cpp               | 7 +++----
 test/std/experimental/memory/nothing_to_do.pass.cpp        | 7 +++----
 test/std/experimental/nothing_to_do.pass.cpp               | 7 +++----
 .../experimental/simd/simd.abi/vector_extension.pass.cpp   | 7 +++----
 test/std/experimental/simd/simd.access/default.pass.cpp    | 7 +++----
 test/std/experimental/simd/simd.casts/simd_cast.pass.cpp   | 7 +++----
 .../experimental/simd/simd.casts/static_simd_cast.pass.cpp | 7 +++----
 test/std/experimental/simd/simd.cons/broadcast.pass.cpp    | 7 +++----
 test/std/experimental/simd/simd.cons/default.pass.cpp      | 7 +++----
 test/std/experimental/simd/simd.cons/generator.pass.cpp    | 7 +++----
 test/std/experimental/simd/simd.cons/load.pass.cpp         | 7 +++----
 test/std/experimental/simd/simd.mem/load.pass.cpp          | 7 +++----
 test/std/experimental/simd/simd.mem/store.pass.cpp         | 7 +++----
 .../experimental/simd/simd.traits/abi_for_size.pass.cpp    | 7 +++----
 test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp | 7 +++----
 test/std/experimental/simd/simd.traits/is_simd.pass.cpp    | 7 +++----
 .../simd/simd.traits/is_simd_flag_type.pass.cpp            | 7 +++----
 .../experimental/simd/simd.traits/is_simd_mask.pass.cpp    | 7 +++----
 .../utilities/meta/meta.detect/detected_or.pass.cpp        | 7 +++----
 .../utilities/meta/meta.detect/detected_t.pass.cpp         | 7 +++----
 .../utilities/meta/meta.detect/is_detected.pass.cpp        | 7 +++----
 .../meta/meta.detect/is_detected_convertible.pass.cpp      | 7 +++----
 .../utilities/meta/meta.detect/is_detected_exact.pass.cpp  | 7 +++----
 test/std/experimental/utilities/nothing_to_do.pass.cpp     | 7 +++----
 .../propagate_const.assignment/assign.pass.cpp             | 7 +++----
 .../assign_convertible_element_type.pass.cpp               | 7 +++----
 .../assign_convertible_propagate_const.pass.cpp            | 7 +++----
 .../assign_element_type.pass.cpp                           | 7 +++----
 .../propagate_const.assignment/move_assign.pass.cpp        | 7 +++----
 .../move_assign_convertible.pass.cpp                       | 7 +++----
 .../move_assign_convertible_propagate_const.pass.cpp       | 7 +++----
 .../convertible_element_type.explicit.ctor.pass.cpp        | 7 +++----
 .../convertible_element_type.non-explicit.ctor.pass.cpp    | 7 +++----
 .../convertible_propagate_const.copy_ctor.pass.cpp         | 7 +++----
 ...convertible_propagate_const.explicit.move_ctor.pass.cpp | 7 +++----
 .../convertible_propagate_const.move_ctor.pass.cpp         | 7 +++----
 .../propagate_const.ctors/copy_ctor.pass.cpp               | 7 +++----
 .../element_type.explicit.ctor.pass.cpp                    | 7 +++----
 .../element_type.non-explicit.ctor.pass.cpp                | 7 +++----
 .../propagate_const.ctors/move_ctor.pass.cpp               | 7 +++----
 .../dereference.pass.cpp                                   | 7 +++----
 .../explicit_operator_element_type_ptr.pass.cpp            | 7 +++----
 .../propagate_const.non-const_observers/get.pass.cpp       | 7 +++----
 .../propagate_const.non-const_observers/op_arrow.pass.cpp  | 7 +++----
 .../operator_element_type_ptr.pass.cpp                     | 7 +++----
 .../propagate_const.observers/dereference.pass.cpp         | 7 +++----
 .../explicit_operator_element_type_ptr.pass.cpp            | 7 +++----
 .../propagate_const.observers/get.pass.cpp                 | 7 +++----
 .../propagate_const.observers/op_arrow.pass.cpp            | 7 +++----
 .../operator_element_type_ptr.pass.cpp                     | 7 +++----
 .../propagate_const/propagate_const.class/swap.pass.cpp    | 7 +++----
 .../propagate_const.nonmembers/hash.pass.cpp               | 7 +++----
 .../equal_to.pass.cpp                                      | 7 +++----
 .../greater.pass.cpp                                       | 7 +++----
 .../greater_equal.pass.cpp                                 | 7 +++----
 .../less.pass.cpp                                          | 7 +++----
 .../less_equal.pass.cpp                                    | 7 +++----
 .../not_equal_to.pass.cpp                                  | 7 +++----
 .../propagate_const.relops/equal.pass.cpp                  | 7 +++----
 .../propagate_const.relops/greater_equal.pass.cpp          | 7 +++----
 .../propagate_const.relops/greater_than.pass.cpp           | 7 +++----
 .../propagate_const.relops/less_equal.pass.cpp             | 7 +++----
 .../propagate_const.relops/less_than.pass.cpp              | 7 +++----
 .../propagate_const.relops/not_equal.pass.cpp              | 7 +++----
 .../propagate_const.nonmembers/swap.pass.cpp               | 7 +++----
 .../utility/utility.erased.type/erased_type.pass.cpp       | 7 +++----
 .../utilities/utility/utility.synop/includes.pass.cpp      | 7 +++----
 .../input.output/file.streams/c.files/cinttypes.pass.cpp   | 7 +++----
 test/std/input.output/file.streams/c.files/cstdio.pass.cpp | 7 +++----
 test/std/input.output/file.streams/c.files/gets.fail.cpp   | 7 +++----
 .../fstreams/filebuf.assign/member_swap.pass.cpp           | 7 +++----
 .../fstreams/filebuf.assign/move_assign.pass.cpp           | 7 +++----
 .../fstreams/filebuf.assign/nonmember_swap.pass.cpp        | 7 +++----
 .../file.streams/fstreams/filebuf.cons/default.pass.cpp    | 7 +++----
 .../file.streams/fstreams/filebuf.cons/move.pass.cpp       | 7 +++----
 .../fstreams/filebuf.members/open_path.pass.cpp            | 7 +++----
 .../fstreams/filebuf.members/open_pointer.pass.cpp         | 7 +++----
 .../fstreams/filebuf.virtuals/overflow.pass.cpp            | 7 +++----
 .../fstreams/filebuf.virtuals/pbackfail.pass.cpp           | 7 +++----
 .../fstreams/filebuf.virtuals/seekoff.pass.cpp             | 7 +++----
 .../fstreams/filebuf.virtuals/underflow.pass.cpp           | 7 +++----
 .../file.streams/fstreams/filebuf/types.pass.cpp           | 7 +++----
 .../fstreams/fstream.assign/member_swap.pass.cpp           | 7 +++----
 .../fstreams/fstream.assign/move_assign.pass.cpp           | 7 +++----
 .../fstreams/fstream.assign/nonmember_swap.pass.cpp        | 7 +++----
 .../file.streams/fstreams/fstream.cons/default.pass.cpp    | 7 +++----
 .../file.streams/fstreams/fstream.cons/move.pass.cpp       | 7 +++----
 .../file.streams/fstreams/fstream.cons/path.pass.cpp       | 7 +++----
 .../file.streams/fstreams/fstream.cons/pointer.pass.cpp    | 7 +++----
 .../file.streams/fstreams/fstream.cons/string.pass.cpp     | 7 +++----
 .../file.streams/fstreams/fstream.members/close.pass.cpp   | 7 +++----
 .../fstreams/fstream.members/open_path.pass.cpp            | 7 +++----
 .../fstreams/fstream.members/open_pointer.pass.cpp         | 7 +++----
 .../fstreams/fstream.members/open_string.pass.cpp          | 7 +++----
 .../file.streams/fstreams/fstream.members/rdbuf.pass.cpp   | 7 +++----
 .../file.streams/fstreams/fstream/types.pass.cpp           | 7 +++----
 .../fstreams/ifstream.assign/member_swap.pass.cpp          | 7 +++----
 .../fstreams/ifstream.assign/move_assign.pass.cpp          | 7 +++----
 .../fstreams/ifstream.assign/nonmember_swap.pass.cpp       | 7 +++----
 .../file.streams/fstreams/ifstream.cons/default.pass.cpp   | 7 +++----
 .../file.streams/fstreams/ifstream.cons/move.pass.cpp      | 7 +++----
 .../file.streams/fstreams/ifstream.cons/path.pass.cpp      | 7 +++----
 .../file.streams/fstreams/ifstream.cons/pointer.pass.cpp   | 7 +++----
 .../file.streams/fstreams/ifstream.cons/string.pass.cpp    | 7 +++----
 .../file.streams/fstreams/ifstream.members/close.pass.cpp  | 7 +++----
 .../fstreams/ifstream.members/open_path.pass.cpp           | 7 +++----
 .../fstreams/ifstream.members/open_pointer.pass.cpp        | 7 +++----
 .../fstreams/ifstream.members/open_string.pass.cpp         | 7 +++----
 .../file.streams/fstreams/ifstream.members/rdbuf.pass.cpp  | 7 +++----
 .../file.streams/fstreams/ifstream/types.pass.cpp          | 7 +++----
 .../fstreams/ofstream.assign/member_swap.pass.cpp          | 7 +++----
 .../fstreams/ofstream.assign/move_assign.pass.cpp          | 7 +++----
 .../fstreams/ofstream.assign/nonmember_swap.pass.cpp       | 7 +++----
 .../file.streams/fstreams/ofstream.cons/default.pass.cpp   | 7 +++----
 .../file.streams/fstreams/ofstream.cons/move.pass.cpp      | 7 +++----
 .../file.streams/fstreams/ofstream.cons/path.pass.cpp      | 7 +++----
 .../file.streams/fstreams/ofstream.cons/pointer.pass.cpp   | 7 +++----
 .../file.streams/fstreams/ofstream.cons/string.pass.cpp    | 7 +++----
 .../file.streams/fstreams/ofstream.members/close.pass.cpp  | 7 +++----
 .../fstreams/ofstream.members/open_path.pass.cpp           | 7 +++----
 .../fstreams/ofstream.members/open_pointer.pass.cpp        | 7 +++----
 .../fstreams/ofstream.members/open_string.pass.cpp         | 7 +++----
 .../file.streams/fstreams/ofstream.members/rdbuf.pass.cpp  | 7 +++----
 .../file.streams/fstreams/ofstream/types.pass.cpp          | 7 +++----
 test/std/input.output/file.streams/nothing_to_do.pass.cpp  | 7 +++----
 .../directory_entry.cons/copy.pass.cpp                     | 7 +++----
 .../directory_entry.cons/copy_assign.pass.cpp              | 7 +++----
 .../directory_entry.cons/default.pass.cpp                  | 7 +++----
 .../directory_entry.cons/default_const.pass.cpp            | 7 +++----
 .../directory_entry.cons/move.pass.cpp                     | 7 +++----
 .../directory_entry.cons/move_assign.pass.cpp              | 7 +++----
 .../directory_entry.cons/path.pass.cpp                     | 7 +++----
 .../directory_entry.mods/assign.pass.cpp                   | 7 +++----
 .../directory_entry.mods/refresh.pass.cpp                  | 7 +++----
 .../directory_entry.mods/replace_filename.pass.cpp         | 7 +++----
 .../directory_entry.obs/comparisons.pass.cpp               | 7 +++----
 .../directory_entry.obs/file_size.pass.cpp                 | 7 +++----
 .../directory_entry.obs/file_type_obs.pass.cpp             | 7 +++----
 .../directory_entry.obs/hard_link_count.pass.cpp           | 7 +++----
 .../directory_entry.obs/last_write_time.pass.cpp           | 7 +++----
 .../directory_entry.obs/path.pass.cpp                      | 7 +++----
 .../directory_entry.obs/status.pass.cpp                    | 7 +++----
 .../directory_entry.obs/symlink_status.pass.cpp            | 7 +++----
 .../directory_iterator.members/copy.pass.cpp               | 7 +++----
 .../directory_iterator.members/copy_assign.pass.cpp        | 7 +++----
 .../directory_iterator.members/ctor.pass.cpp               | 7 +++----
 .../directory_iterator.members/default_ctor.pass.cpp       | 7 +++----
 .../directory_iterator.members/increment.pass.cpp          | 7 +++----
 .../directory_iterator.members/move.pass.cpp               | 7 +++----
 .../directory_iterator.members/move_assign.pass.cpp        | 7 +++----
 .../directory_iterator.nonmembers/begin_end.pass.cpp       | 7 +++----
 .../filesystems/class.directory_iterator/types.pass.cpp    | 7 +++----
 .../class.file_status/file_status.cons.pass.cpp            | 7 +++----
 .../class.file_status/file_status.mods.pass.cpp            | 7 +++----
 .../filesystems/class.file_status/file_status.obs.pass.cpp | 7 +++----
 .../filesystem_error.members.pass.cpp                      | 7 +++----
 .../filesystems/class.path/path.itr/iterator.pass.cpp      | 7 +++----
 .../class.path/path.member/path.append.pass.cpp            | 7 +++----
 .../path.member/path.assign/braced_init.pass.cpp           | 7 +++----
 .../class.path/path.member/path.assign/copy.pass.cpp       | 7 +++----
 .../class.path/path.member/path.assign/move.pass.cpp       | 7 +++----
 .../class.path/path.member/path.assign/source.pass.cpp     | 7 +++----
 .../class.path/path.member/path.compare.pass.cpp           | 7 +++----
 .../class.path/path.member/path.concat.pass.cpp            | 7 +++----
 .../class.path/path.member/path.construct/copy.pass.cpp    | 7 +++----
 .../class.path/path.member/path.construct/default.pass.cpp | 7 +++----
 .../class.path/path.member/path.construct/move.pass.cpp    | 7 +++----
 .../class.path/path.member/path.construct/source.pass.cpp  | 7 +++----
 .../class.path/path.member/path.decompose/empty.fail.cpp   | 7 +++----
 .../path.member/path.decompose/path.decompose.pass.cpp     | 7 +++----
 .../path.member/path.gen/lexically_normal.pass.cpp         | 7 +++----
 .../path.gen/lexically_relative_and_proximate.pass.cpp     | 7 +++----
 .../path.generic.obs/generic_string_alloc.pass.cpp         | 7 +++----
 .../path.member/path.generic.obs/named_overloads.pass.cpp  | 7 +++----
 .../class.path/path.member/path.modifiers/clear.pass.cpp   | 7 +++----
 .../path.member/path.modifiers/make_preferred.pass.cpp     | 7 +++----
 .../path.member/path.modifiers/remove_filename.pass.cpp    | 7 +++----
 .../path.member/path.modifiers/replace_extension.pass.cpp  | 7 +++----
 .../path.member/path.modifiers/replace_filename.pass.cpp   | 7 +++----
 .../class.path/path.member/path.modifiers/swap.pass.cpp    | 7 +++----
 .../class.path/path.member/path.native.obs/c_str.pass.cpp  | 7 +++----
 .../path.member/path.native.obs/named_overloads.pass.cpp   | 7 +++----
 .../class.path/path.member/path.native.obs/native.pass.cpp | 7 +++----
 .../path.member/path.native.obs/operator_string.pass.cpp   | 7 +++----
 .../path.member/path.native.obs/string_alloc.pass.cpp      | 7 +++----
 .../path.query/tested_in_path_decompose.pass.cpp           | 7 +++----
 .../class.path/path.nonmember/append_op.fail.cpp           | 7 +++----
 .../class.path/path.nonmember/append_op.pass.cpp           | 7 +++----
 .../class.path/path.nonmember/comparison_ops.fail.cpp      | 7 +++----
 .../comparison_ops_tested_elsewhere.pass.cpp               | 7 +++----
 .../path.nonmember/hash_value_tested_elswhere.pass.cpp     | 7 +++----
 .../class.path/path.nonmember/path.factory.pass.cpp        | 7 +++----
 .../filesystems/class.path/path.nonmember/path.io.pass.cpp | 7 +++----
 .../class.path/path.nonmember/path.io.unicode_bug.pass.cpp | 7 +++----
 .../filesystems/class.path/path.nonmember/swap.pass.cpp    | 7 +++----
 .../std/input.output/filesystems/class.path/synop.pass.cpp | 7 +++----
 .../class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp    | 7 +++----
 .../rec.dir.itr.members/copy_assign.pass.cpp               | 7 +++----
 .../class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp    | 7 +++----
 .../class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp   | 7 +++----
 .../rec.dir.itr.members/disable_recursion_pending.pass.cpp | 7 +++----
 .../rec.dir.itr.members/increment.pass.cpp                 | 7 +++----
 .../class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp    | 7 +++----
 .../rec.dir.itr.members/move_assign.pass.cpp               | 7 +++----
 .../class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp     | 7 +++----
 .../rec.dir.itr.members/recursion_pending.pass.cpp         | 7 +++----
 .../rec.dir.itr.nonmembers/begin_end.pass.cpp              | 7 +++----
 .../filesystems/fs.enum/enum.copy_options.pass.cpp         | 7 +++----
 .../filesystems/fs.enum/enum.directory_options.pass.cpp    | 7 +++----
 .../filesystems/fs.enum/enum.file_type.pass.cpp            | 7 +++----
 .../filesystems/fs.enum/enum.path.format.pass.cpp          | 7 +++----
 .../filesystems/fs.enum/enum.perm_options.pass.cpp         | 7 +++----
 .../input.output/filesystems/fs.enum/enum.perms.pass.cpp   | 7 +++----
 .../filesystems/fs.error.report/tested_elsewhere.pass.cpp  | 7 +++----
 .../fs.filesystem.synopsis/file_time_type.pass.cpp         | 7 +++----
 .../fs.op.funcs/fs.op.absolute/absolute.pass.cpp           | 7 +++----
 .../fs.op.funcs/fs.op.canonical/canonical.pass.cpp         | 7 +++----
 .../filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp       | 7 +++----
 .../fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp         | 7 +++----
 .../fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp   | 7 +++----
 .../fs.op.create_directories/create_directories.pass.cpp   | 7 +++----
 .../fs.op.create_directory/create_directory.pass.cpp       | 7 +++----
 .../create_directory_with_attributes.pass.cpp              | 7 +++----
 .../create_directory_symlink.pass.cpp                      | 7 +++----
 .../fs.op.create_hard_link/create_hard_link.pass.cpp       | 7 +++----
 .../fs.op.create_symlink/create_symlink.pass.cpp           | 7 +++----
 .../fs.op.funcs/fs.op.current_path/current_path.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp       | 7 +++----
 .../filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.file_size/file_size.pass.cpp         | 7 +++----
 .../fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp  | 7 +++----
 .../fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp | 7 +++----
 .../fs.op.is_char_file/is_character_file.pass.cpp          | 7 +++----
 .../fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp           | 7 +++----
 .../filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp | 7 +++----
 .../fs.op.funcs/fs.op.is_other/is_other.pass.cpp           | 7 +++----
 .../fs.op.is_regular_file/is_regular_file.pass.cpp         | 7 +++----
 .../fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp         | 7 +++----
 .../fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp       | 7 +++----
 .../fs.op.last_write_time/last_write_time.pass.cpp         | 7 +++----
 .../fs.op.funcs/fs.op.permissions/permissions.pass.cpp     | 7 +++----
 .../fs.op.funcs/fs.op.proximate/proximate.pass.cpp         | 7 +++----
 .../fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.relative/relative.pass.cpp           | 7 +++----
 .../filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp       | 7 +++----
 .../filesystems/fs.op.funcs/fs.op.rename/rename.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp     | 7 +++----
 .../filesystems/fs.op.funcs/fs.op.space/space.pass.cpp     | 7 +++----
 .../filesystems/fs.op.funcs/fs.op.status/status.pass.cpp   | 7 +++----
 .../fs.op.funcs/fs.op.status_known/status_known.pass.cpp   | 7 +++----
 .../fs.op.symlink_status/symlink_status.pass.cpp           | 7 +++----
 .../fs.op.temp_dir_path/temp_directory_path.pass.cpp       | 7 +++----
 .../fs.op.weakly_canonical/weakly_canonical.pass.cpp       | 7 +++----
 .../filesystems/fs.req.macros/feature_macro.pass.cpp       | 7 +++----
 .../filesystems/fs.req.namespace/namespace.fail.cpp        | 7 +++----
 .../filesystems/fs.req.namespace/namespace.pass.cpp        | 7 +++----
 .../input.output.general/nothing_to_do.pass.cpp            | 7 +++----
 .../iostream.format/ext.manip/get_money.pass.cpp           | 7 +++----
 .../iostream.format/ext.manip/get_time.pass.cpp            | 7 +++----
 .../iostream.format/ext.manip/put_money.pass.cpp           | 7 +++----
 .../iostream.format/ext.manip/put_time.pass.cpp            | 7 +++----
 .../iostreamclass/iostream.assign/member_swap.pass.cpp     | 7 +++----
 .../iostreamclass/iostream.assign/move_assign.pass.cpp     | 7 +++----
 .../iostreamclass/iostream.cons/move.pass.cpp              | 7 +++----
 .../iostreamclass/iostream.cons/streambuf.pass.cpp         | 7 +++----
 .../iostreamclass/iostream.dest/nothing_to_do.pass.cpp     | 7 +++----
 .../input.streams/iostreamclass/types.pass.cpp             | 7 +++----
 .../istream.formatted.arithmetic/bool.pass.cpp             | 7 +++----
 .../istream.formatted.arithmetic/double.pass.cpp           | 7 +++----
 .../istream.formatted.arithmetic/float.pass.cpp            | 7 +++----
 .../istream.formatted.arithmetic/int.pass.cpp              | 7 +++----
 .../istream.formatted.arithmetic/long.pass.cpp             | 7 +++----
 .../istream.formatted.arithmetic/long_double.pass.cpp      | 7 +++----
 .../istream.formatted.arithmetic/long_long.pass.cpp        | 7 +++----
 .../istream.formatted.arithmetic/pointer.pass.cpp          | 7 +++----
 .../istream.formatted.arithmetic/short.pass.cpp            | 7 +++----
 .../istream.formatted.arithmetic/unsigned_int.pass.cpp     | 7 +++----
 .../istream.formatted.arithmetic/unsigned_long.pass.cpp    | 7 +++----
 .../unsigned_long_long.pass.cpp                            | 7 +++----
 .../istream.formatted.arithmetic/unsigned_short.pass.cpp   | 7 +++----
 .../istream.formatted.reqmts/tested_elsewhere.pass.cpp     | 7 +++----
 .../istream_extractors/basic_ios.pass.cpp                  | 7 +++----
 .../istream.formatted/istream_extractors/chart.pass.cpp    | 7 +++----
 .../istream.formatted/istream_extractors/ios_base.pass.cpp | 7 +++----
 .../istream.formatted/istream_extractors/istream.pass.cpp  | 7 +++----
 .../istream_extractors/signed_char.pass.cpp                | 7 +++----
 .../istream_extractors/signed_char_pointer.pass.cpp        | 7 +++----
 .../istream_extractors/streambuf.pass.cpp                  | 7 +++----
 .../istream_extractors/unsigned_char.pass.cpp              | 7 +++----
 .../istream_extractors/unsigned_char_pointer.pass.cpp      | 7 +++----
 .../istream_extractors/wchar_t_pointer.pass.cpp            | 7 +++----
 .../input.streams/istream.formatted/nothing_to_do.pass.cpp | 7 +++----
 .../input.streams/istream.manip/ws.pass.cpp                | 7 +++----
 .../input.streams/istream.rvalue/rvalue.pass.cpp           | 7 +++----
 .../input.streams/istream.unformatted/get.pass.cpp         | 7 +++----
 .../input.streams/istream.unformatted/get_chart.pass.cpp   | 7 +++----
 .../istream.unformatted/get_pointer_size.pass.cpp          | 7 +++----
 .../istream.unformatted/get_pointer_size_chart.pass.cpp    | 7 +++----
 .../istream.unformatted/get_streambuf.pass.cpp             | 7 +++----
 .../istream.unformatted/get_streambuf_chart.pass.cpp       | 7 +++----
 .../istream.unformatted/getline_pointer_size.pass.cpp      | 7 +++----
 .../getline_pointer_size_chart.pass.cpp                    | 7 +++----
 .../input.streams/istream.unformatted/ignore.pass.cpp      | 7 +++----
 .../input.streams/istream.unformatted/ignore_0xff.pass.cpp | 7 +++----
 .../input.streams/istream.unformatted/peek.pass.cpp        | 7 +++----
 .../input.streams/istream.unformatted/putback.pass.cpp     | 7 +++----
 .../input.streams/istream.unformatted/read.pass.cpp        | 7 +++----
 .../input.streams/istream.unformatted/readsome.pass.cpp    | 7 +++----
 .../input.streams/istream.unformatted/seekg.pass.cpp       | 7 +++----
 .../input.streams/istream.unformatted/seekg_off.pass.cpp   | 7 +++----
 .../input.streams/istream.unformatted/sync.pass.cpp        | 7 +++----
 .../input.streams/istream.unformatted/tellg.pass.cpp       | 7 +++----
 .../input.streams/istream.unformatted/unget.pass.cpp       | 7 +++----
 .../istream/istream.assign/member_swap.pass.cpp            | 7 +++----
 .../istream/istream.assign/move_assign.pass.cpp            | 7 +++----
 .../input.streams/istream/istream.cons/copy.fail.cpp       | 7 +++----
 .../input.streams/istream/istream.cons/move.pass.cpp       | 7 +++----
 .../input.streams/istream/istream.cons/streambuf.pass.cpp  | 7 +++----
 .../input.streams/istream/istream_sentry/ctor.pass.cpp     | 7 +++----
 .../iostream.format/input.streams/istream/types.pass.cpp   | 7 +++----
 .../input.output/iostream.format/nothing_to_do.pass.cpp    | 7 +++----
 .../output.streams/ostream.assign/member_swap.pass.cpp     | 7 +++----
 .../output.streams/ostream.assign/move_assign.pass.cpp     | 7 +++----
 .../output.streams/ostream.cons/move.pass.cpp              | 7 +++----
 .../output.streams/ostream.cons/streambuf.pass.cpp         | 7 +++----
 .../ostream.formatted/nothing_to_do.pass.cpp               | 7 +++----
 .../ostream.formatted.reqmts/tested_elsewhere.pass.cpp     | 7 +++----
 .../ostream.inserters.arithmetic/bool.pass.cpp             | 7 +++----
 .../ostream.inserters.arithmetic/double.pass.cpp           | 7 +++----
 .../ostream.inserters.arithmetic/float.pass.cpp            | 7 +++----
 .../ostream.inserters.arithmetic/int.pass.cpp              | 7 +++----
 .../ostream.inserters.arithmetic/long.pass.cpp             | 7 +++----
 .../ostream.inserters.arithmetic/long_double.pass.cpp      | 7 +++----
 .../ostream.inserters.arithmetic/long_long.pass.cpp        | 7 +++----
 .../ostream.inserters.arithmetic/minmax_showbase.pass.cpp  | 7 +++----
 .../ostream.inserters.arithmetic/minus1.pass.cpp           | 7 +++----
 .../ostream.inserters.arithmetic/pointer.pass.cpp          | 7 +++----
 .../ostream.inserters.arithmetic/short.pass.cpp            | 7 +++----
 .../ostream.inserters.arithmetic/unsigned_int.pass.cpp     | 7 +++----
 .../ostream.inserters.arithmetic/unsigned_long.pass.cpp    | 7 +++----
 .../unsigned_long_long.pass.cpp                            | 7 +++----
 .../ostream.inserters.arithmetic/unsigned_short.pass.cpp   | 7 +++----
 .../ostream.inserters.character/CharT.pass.cpp             | 7 +++----
 .../ostream.inserters.character/CharT_pointer.pass.cpp     | 7 +++----
 .../ostream.inserters.character/char.pass.cpp              | 7 +++----
 .../ostream.inserters.character/char_pointer.pass.cpp      | 7 +++----
 .../ostream.inserters.character/char_to_wide.pass.cpp      | 7 +++----
 .../char_to_wide_pointer.pass.cpp                          | 7 +++----
 .../ostream.inserters.character/signed_char.pass.cpp       | 7 +++----
 .../signed_char_pointer.pass.cpp                           | 7 +++----
 .../ostream.inserters.character/unsigned_char.pass.cpp     | 7 +++----
 .../unsigned_char_pointer.pass.cpp                         | 7 +++----
 .../ostream.formatted/ostream.inserters/basic_ios.pass.cpp | 7 +++----
 .../ostream.formatted/ostream.inserters/ios_base.pass.cpp  | 7 +++----
 .../ostream.formatted/ostream.inserters/ostream.pass.cpp   | 7 +++----
 .../ostream.formatted/ostream.inserters/streambuf.pass.cpp | 7 +++----
 .../output.streams/ostream.manip/endl.pass.cpp             | 7 +++----
 .../output.streams/ostream.manip/ends.pass.cpp             | 7 +++----
 .../output.streams/ostream.manip/flush.pass.cpp            | 7 +++----
 .../output.streams/ostream.rvalue/CharT_pointer.pass.cpp   | 7 +++----
 .../output.streams/ostream.seeks/seekp.pass.cpp            | 7 +++----
 .../output.streams/ostream.seeks/seekp2.pass.cpp           | 7 +++----
 .../output.streams/ostream.seeks/tellp.pass.cpp            | 7 +++----
 .../output.streams/ostream.unformatted/flush.pass.cpp      | 7 +++----
 .../output.streams/ostream.unformatted/put.pass.cpp        | 7 +++----
 .../output.streams/ostream.unformatted/write.pass.cpp      | 7 +++----
 .../iostream.format/output.streams/ostream/types.pass.cpp  | 7 +++----
 .../output.streams/ostream_sentry/construct.pass.cpp       | 7 +++----
 .../output.streams/ostream_sentry/destruct.pass.cpp        | 7 +++----
 .../iostream.format/quoted.manip/quoted.pass.cpp           | 7 +++----
 .../iostream.format/quoted.manip/quoted_char.fail.cpp      | 7 +++----
 .../iostream.format/quoted.manip/quoted_traits.fail.cpp    | 7 +++----
 .../iostream.format/std.manip/resetiosflags.pass.cpp       | 7 +++----
 .../iostream.format/std.manip/setbase.pass.cpp             | 7 +++----
 .../iostream.format/std.manip/setfill.pass.cpp             | 7 +++----
 .../iostream.format/std.manip/setiosflags.pass.cpp         | 7 +++----
 .../iostream.format/std.manip/setprecision.pass.cpp        | 7 +++----
 .../input.output/iostream.format/std.manip/setw.pass.cpp   | 7 +++----
 test/std/input.output/iostream.forward/iosfwd.pass.cpp     | 7 +++----
 .../iostream.objects/narrow.stream.objects/cerr.pass.cpp   | 7 +++----
 .../iostream.objects/narrow.stream.objects/cin.pass.cpp    | 7 +++----
 .../iostream.objects/narrow.stream.objects/clog.pass.cpp   | 7 +++----
 .../iostream.objects/narrow.stream.objects/cout.pass.cpp   | 7 +++----
 .../iostream.objects/wide.stream.objects/wcerr.pass.cpp    | 7 +++----
 .../iostream.objects/wide.stream.objects/wcin.pass.cpp     | 7 +++----
 .../iostream.objects/wide.stream.objects/wclog.pass.cpp    | 7 +++----
 .../iostream.objects/wide.stream.objects/wcout.pass.cpp    | 7 +++----
 .../iostreams.base/fpos/fpos.members/state.pass.cpp        | 7 +++----
 .../iostreams.base/fpos/fpos.operations/addition.pass.cpp  | 7 +++----
 .../iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp  | 7 +++----
 .../fpos/fpos.operations/difference.pass.cpp               | 7 +++----
 .../iostreams.base/fpos/fpos.operations/eq_int.pass.cpp    | 7 +++----
 .../iostreams.base/fpos/fpos.operations/offset.pass.cpp    | 7 +++----
 .../fpos/fpos.operations/streamsize.pass.cpp               | 7 +++----
 .../fpos/fpos.operations/subtraction.pass.cpp              | 7 +++----
 .../iostreams.base/fpos/nothing_to_do.pass.cpp             | 7 +++----
 .../iostreams.base/ios.base/fmtflags.state/flags.pass.cpp  | 7 +++----
 .../ios.base/fmtflags.state/flags_fmtflags.pass.cpp        | 7 +++----
 .../ios.base/fmtflags.state/precision.pass.cpp             | 7 +++----
 .../ios.base/fmtflags.state/precision_streamsize.pass.cpp  | 7 +++----
 .../ios.base/fmtflags.state/setf_fmtflags.pass.cpp         | 7 +++----
 .../ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp    | 7 +++----
 .../ios.base/fmtflags.state/unsetf_mask.pass.cpp           | 7 +++----
 .../iostreams.base/ios.base/fmtflags.state/width.pass.cpp  | 7 +++----
 .../ios.base/fmtflags.state/width_streamsize.pass.cpp      | 7 +++----
 .../ios.base/ios.base.callback/register_callback.pass.cpp  | 7 +++----
 .../iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp    | 7 +++----
 .../ios.base/ios.base.locales/getloc.pass.cpp              | 7 +++----
 .../ios.base/ios.base.locales/imbue.pass.cpp               | 7 +++----
 .../ios.base/ios.base.storage/iword.pass.cpp               | 7 +++----
 .../ios.base/ios.base.storage/pword.pass.cpp               | 7 +++----
 .../ios.base/ios.base.storage/xalloc.pass.cpp              | 7 +++----
 .../ios.base/ios.members.static/sync_with_stdio.pass.cpp   | 7 +++----
 .../ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp  | 7 +++----
 .../ios_failure/ctor_char_pointer_error_code.pass.cpp      | 7 +++----
 .../ios.types/ios_failure/ctor_string_error_code.pass.cpp  | 7 +++----
 .../ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp      | 7 +++----
 .../ios.base/ios.types/ios_iostate/iostate.pass.cpp        | 7 +++----
 .../ios.base/ios.types/ios_openmode/openmode.pass.cpp      | 7 +++----
 .../ios.base/ios.types/ios_seekdir/seekdir.pass.cpp        | 7 +++----
 .../ios.base/ios.types/nothing_to_do.pass.cpp              | 7 +++----
 .../iostreams.base/ios.base/nothing_to_do.pass.cpp         | 7 +++----
 .../ios/basic.ios.cons/ctor_streambuf.pass.cpp             | 7 +++----
 .../iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp  | 7 +++----
 .../iostreams.base/ios/basic.ios.members/fill.pass.cpp     | 7 +++----
 .../ios/basic.ios.members/fill_char_type.pass.cpp          | 7 +++----
 .../iostreams.base/ios/basic.ios.members/imbue.pass.cpp    | 7 +++----
 .../iostreams.base/ios/basic.ios.members/move.pass.cpp     | 7 +++----
 .../iostreams.base/ios/basic.ios.members/narrow.pass.cpp   | 7 +++----
 .../iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp    | 7 +++----
 .../ios/basic.ios.members/rdbuf_streambuf.pass.cpp         | 7 +++----
 .../ios/basic.ios.members/set_rdbuf.pass.cpp               | 7 +++----
 .../iostreams.base/ios/basic.ios.members/swap.pass.cpp     | 7 +++----
 .../iostreams.base/ios/basic.ios.members/tie.pass.cpp      | 7 +++----
 .../ios/basic.ios.members/tie_ostream.pass.cpp             | 7 +++----
 .../iostreams.base/ios/basic.ios.members/widen.pass.cpp    | 7 +++----
 .../iostreams.base/ios/iostate.flags/bad.pass.cpp          | 7 +++----
 .../iostreams.base/ios/iostate.flags/bool.pass.cpp         | 7 +++----
 .../iostreams.base/ios/iostate.flags/clear.pass.cpp        | 7 +++----
 .../iostreams.base/ios/iostate.flags/eof.pass.cpp          | 7 +++----
 .../iostreams.base/ios/iostate.flags/exceptions.pass.cpp   | 7 +++----
 .../ios/iostate.flags/exceptions_iostate.pass.cpp          | 7 +++----
 .../iostreams.base/ios/iostate.flags/fail.pass.cpp         | 7 +++----
 .../iostreams.base/ios/iostate.flags/good.pass.cpp         | 7 +++----
 .../iostreams.base/ios/iostate.flags/not.pass.cpp          | 7 +++----
 .../iostreams.base/ios/iostate.flags/rdstate.pass.cpp      | 7 +++----
 .../iostreams.base/ios/iostate.flags/setstate.pass.cpp     | 7 +++----
 test/std/input.output/iostreams.base/ios/types.pass.cpp    | 7 +++----
 .../iostreams.base/is_error_code_enum_io_errc.pass.cpp     | 7 +++----
 .../std.ios.manip/adjustfield.manip/internal.pass.cpp      | 7 +++----
 .../std.ios.manip/adjustfield.manip/left.pass.cpp          | 7 +++----
 .../std.ios.manip/adjustfield.manip/right.pass.cpp         | 7 +++----
 .../std.ios.manip/basefield.manip/dec.pass.cpp             | 7 +++----
 .../std.ios.manip/basefield.manip/hex.pass.cpp             | 7 +++----
 .../std.ios.manip/basefield.manip/oct.pass.cpp             | 7 +++----
 .../error.reporting/iostream_category.pass.cpp             | 7 +++----
 .../std.ios.manip/error.reporting/make_error_code.pass.cpp | 7 +++----
 .../error.reporting/make_error_condition.pass.cpp          | 7 +++----
 .../std.ios.manip/floatfield.manip/defaultfloat.pass.cpp   | 7 +++----
 .../std.ios.manip/floatfield.manip/fixed.pass.cpp          | 7 +++----
 .../std.ios.manip/floatfield.manip/hexfloat.pass.cpp       | 7 +++----
 .../std.ios.manip/floatfield.manip/scientific.pass.cpp     | 7 +++----
 .../std.ios.manip/fmtflags.manip/boolalpha.pass.cpp        | 7 +++----
 .../std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp      | 7 +++----
 .../std.ios.manip/fmtflags.manip/noshowbase.pass.cpp       | 7 +++----
 .../std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp      | 7 +++----
 .../std.ios.manip/fmtflags.manip/noshowpos.pass.cpp        | 7 +++----
 .../std.ios.manip/fmtflags.manip/noskipws.pass.cpp         | 7 +++----
 .../std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp        | 7 +++----
 .../std.ios.manip/fmtflags.manip/nouppercase.pass.cpp      | 7 +++----
 .../std.ios.manip/fmtflags.manip/showbase.pass.cpp         | 7 +++----
 .../std.ios.manip/fmtflags.manip/showpoint.pass.cpp        | 7 +++----
 .../std.ios.manip/fmtflags.manip/showpos.pass.cpp          | 7 +++----
 .../std.ios.manip/fmtflags.manip/skipws.pass.cpp           | 7 +++----
 .../std.ios.manip/fmtflags.manip/unitbuf.pass.cpp          | 7 +++----
 .../std.ios.manip/fmtflags.manip/uppercase.pass.cpp        | 7 +++----
 .../iostreams.base/std.ios.manip/nothing_to_do.pass.cpp    | 7 +++----
 .../iostreams.base/stream.types/streamoff.pass.cpp         | 7 +++----
 .../iostreams.base/stream.types/streamsize.pass.cpp        | 7 +++----
 .../iostream.limits.imbue/tested_elsewhere.pass.cpp        | 7 +++----
 .../iostreams.limits.pos/nothing_to_do.pass.cpp            | 7 +++----
 .../iostreams.threadsafety/nothing_to_do.pass.cpp          | 7 +++----
 .../iostreams.requirements/nothing_to_do.pass.cpp          | 7 +++----
 test/std/input.output/nothing_to_do.pass.cpp               | 7 +++----
 .../streambuf.reqts/tested_elsewhere.pass.cpp              | 7 +++----
 .../stream.buffers/streambuf/streambuf.cons/copy.fail.cpp  | 7 +++----
 .../stream.buffers/streambuf/streambuf.cons/copy.pass.cpp  | 7 +++----
 .../streambuf/streambuf.cons/default.fail.cpp              | 7 +++----
 .../streambuf/streambuf.cons/default.pass.cpp              | 7 +++----
 .../streambuf/streambuf.members/nothing_to_do.pass.cpp     | 7 +++----
 .../streambuf.members/streambuf.buffer/pubseekoff.pass.cpp | 7 +++----
 .../streambuf.members/streambuf.buffer/pubseekpos.pass.cpp | 7 +++----
 .../streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp  | 7 +++----
 .../streambuf.members/streambuf.buffer/pubsync.pass.cpp    | 7 +++----
 .../streambuf.members/streambuf.locales/locales.pass.cpp   | 7 +++----
 .../streambuf.members/streambuf.pub.get/in_avail.pass.cpp  | 7 +++----
 .../streambuf.members/streambuf.pub.get/sbumpc.pass.cpp    | 7 +++----
 .../streambuf.members/streambuf.pub.get/sgetc.pass.cpp     | 7 +++----
 .../streambuf.members/streambuf.pub.get/sgetn.pass.cpp     | 7 +++----
 .../streambuf.members/streambuf.pub.get/snextc.pass.cpp    | 7 +++----
 .../streambuf.pub.pback/sputbackc.pass.cpp                 | 7 +++----
 .../streambuf.members/streambuf.pub.pback/sungetc.pass.cpp | 7 +++----
 .../streambuf.members/streambuf.pub.put/sputc.pass.cpp     | 7 +++----
 .../streambuf.members/streambuf.pub.put/sputn.pass.cpp     | 7 +++----
 .../streambuf/streambuf.protected/nothing_to_do.pass.cpp   | 7 +++----
 .../streambuf.protected/streambuf.assign/assign.pass.cpp   | 7 +++----
 .../streambuf.protected/streambuf.assign/swap.pass.cpp     | 7 +++----
 .../streambuf.protected/streambuf.get.area/gbump.pass.cpp  | 7 +++----
 .../streambuf.protected/streambuf.get.area/setg.pass.cpp   | 7 +++----
 .../streambuf.protected/streambuf.put.area/pbump.pass.cpp  | 7 +++----
 .../streambuf.put.area/pbump2gig.pass.cpp                  | 7 +++----
 .../streambuf.protected/streambuf.put.area/setp.pass.cpp   | 7 +++----
 .../streambuf/streambuf.virtuals/nothing_to_do.pass.cpp    | 7 +++----
 .../streambuf.virt.buffer/tested_elsewhere.pass.cpp        | 7 +++----
 .../streambuf.virt.get/showmanyc.pass.cpp                  | 7 +++----
 .../streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp   | 7 +++----
 .../streambuf.virt.get/underflow.pass.cpp                  | 7 +++----
 .../streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp  | 7 +++----
 .../streambuf.virt.locales/nothing_to_do.pass.cpp          | 7 +++----
 .../streambuf.virt.pback/pbackfail.pass.cpp                | 7 +++----
 .../streambuf.virt.put/overflow.pass.cpp                   | 7 +++----
 .../streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp  | 7 +++----
 .../input.output/stream.buffers/streambuf/types.pass.cpp   | 7 +++----
 .../istringstream.assign/member_swap.pass.cpp              | 7 +++----
 .../istringstream/istringstream.assign/move.pass.cpp       | 7 +++----
 .../istringstream.assign/nonmember_swap.pass.cpp           | 7 +++----
 .../istringstream/istringstream.cons/default.pass.cpp      | 7 +++----
 .../istringstream/istringstream.cons/move.pass.cpp         | 7 +++----
 .../istringstream/istringstream.cons/string.pass.cpp       | 7 +++----
 .../istringstream/istringstream.members/str.pass.cpp       | 7 +++----
 .../string.streams/istringstream/types.pass.cpp            | 7 +++----
 .../ostringstream.assign/member_swap.pass.cpp              | 7 +++----
 .../ostringstream/ostringstream.assign/move.pass.cpp       | 7 +++----
 .../ostringstream.assign/nonmember_swap.pass.cpp           | 7 +++----
 .../ostringstream/ostringstream.cons/default.pass.cpp      | 7 +++----
 .../ostringstream/ostringstream.cons/move.pass.cpp         | 7 +++----
 .../ostringstream/ostringstream.cons/string.pass.cpp       | 7 +++----
 .../ostringstream/ostringstream.members/str.pass.cpp       | 7 +++----
 .../string.streams/ostringstream/types.pass.cpp            | 7 +++----
 .../stringbuf/stringbuf.assign/member_swap.pass.cpp        | 7 +++----
 .../stringbuf/stringbuf.assign/move.pass.cpp               | 7 +++----
 .../stringbuf/stringbuf.assign/nonmember_swap.pass.cpp     | 7 +++----
 .../stringbuf/stringbuf.cons/default.pass.cpp              | 7 +++----
 .../string.streams/stringbuf/stringbuf.cons/move.pass.cpp  | 7 +++----
 .../stringbuf/stringbuf.cons/string.pass.cpp               | 7 +++----
 .../stringbuf/stringbuf.members/str.pass.cpp               | 7 +++----
 .../stringbuf/stringbuf.virtuals/overflow.pass.cpp         | 7 +++----
 .../stringbuf/stringbuf.virtuals/pbackfail.pass.cpp        | 7 +++----
 .../stringbuf/stringbuf.virtuals/seekoff.pass.cpp          | 7 +++----
 .../stringbuf/stringbuf.virtuals/seekpos.pass.cpp          | 7 +++----
 .../stringbuf/stringbuf.virtuals/setbuf.pass.cpp           | 7 +++----
 .../stringbuf/stringbuf.virtuals/underflow.pass.cpp        | 7 +++----
 .../input.output/string.streams/stringbuf/types.pass.cpp   | 7 +++----
 .../string.streams/stringstream.cons/default.pass.cpp      | 7 +++----
 .../string.streams/stringstream.cons/move.pass.cpp         | 7 +++----
 .../string.streams/stringstream.cons/move2.pass.cpp        | 7 +++----
 .../string.streams/stringstream.cons/string.pass.cpp       | 7 +++----
 .../stringstream.assign/member_swap.pass.cpp               | 7 +++----
 .../stringstream.cons/stringstream.assign/move.pass.cpp    | 7 +++----
 .../stringstream.assign/nonmember_swap.pass.cpp            | 7 +++----
 .../string.streams/stringstream.members/str.pass.cpp       | 7 +++----
 .../string.streams/stringstream/types.pass.cpp             | 7 +++----
 test/std/iterators/iterator.container/data.pass.cpp        | 7 +++----
 test/std/iterators/iterator.container/empty.array.fail.cpp | 7 +++----
 .../iterators/iterator.container/empty.container.fail.cpp  | 7 +++----
 .../iterator.container/empty.initializer_list.fail.cpp     | 7 +++----
 test/std/iterators/iterator.container/empty.pass.cpp       | 7 +++----
 test/std/iterators/iterator.container/size.pass.cpp        | 7 +++----
 .../iterator.primitives/iterator.basic/iterator.pass.cpp   | 7 +++----
 .../iterator.operations/advance.pass.cpp                   | 7 +++----
 .../iterator.operations/distance.pass.cpp                  | 7 +++----
 .../iterator.primitives/iterator.operations/next.pass.cpp  | 7 +++----
 .../iterator.primitives/iterator.operations/prev.pass.cpp  | 7 +++----
 .../iterator.traits/const_pointer.pass.cpp                 | 7 +++----
 .../iterator.traits/const_volatile_pointer.pass.cpp        | 7 +++----
 .../iterator.primitives/iterator.traits/empty.fail.cpp     | 7 +++----
 .../iterator.primitives/iterator.traits/empty.pass.cpp     | 7 +++----
 .../iterator.primitives/iterator.traits/iterator.pass.cpp  | 7 +++----
 .../iterator.primitives/iterator.traits/pointer.pass.cpp   | 7 +++----
 .../iterator.traits/volatile_pointer.pass.cpp              | 7 +++----
 .../iterators/iterator.primitives/nothing_to_do.pass.cpp   | 7 +++----
 .../std.iterator.tags/bidirectional_iterator_tag.pass.cpp  | 7 +++----
 .../std.iterator.tags/forward_iterator_tag.pass.cpp        | 7 +++----
 .../std.iterator.tags/input_iterator_tag.pass.cpp          | 7 +++----
 .../std.iterator.tags/output_iterator_tag.pass.cpp         | 7 +++----
 .../std.iterator.tags/random_access_iterator_tag.pass.cpp  | 7 +++----
 test/std/iterators/iterator.range/begin-end.fail.cpp       | 7 +++----
 test/std/iterators/iterator.range/begin-end.pass.cpp       | 7 +++----
 .../bidirectional.iterators/nothing_to_do.pass.cpp         | 7 +++----
 .../forward.iterators/nothing_to_do.pass.cpp               | 7 +++----
 .../input.iterators/nothing_to_do.pass.cpp                 | 7 +++----
 .../iterator.iterators/nothing_to_do.pass.cpp              | 7 +++----
 .../iterator.requirements.general/nothing_to_do.pass.cpp   | 7 +++----
 .../iterators/iterator.requirements/nothing_to_do.pass.cpp | 7 +++----
 .../output.iterators/nothing_to_do.pass.cpp                | 7 +++----
 .../random.access.iterators/nothing_to_do.pass.cpp         | 7 +++----
 .../std/iterators/iterator.synopsis/nothing_to_do.pass.cpp | 7 +++----
 .../iterators/iterators.general/gcc_workaround.pass.cpp    | 7 +++----
 .../std/iterators/iterators.general/nothing_to_do.pass.cpp | 7 +++----
 .../back.insert.iter.cons/container.fail.cpp               | 7 +++----
 .../back.insert.iter.cons/container.pass.cpp               | 7 +++----
 .../back.insert.iter.op++/post.pass.cpp                    | 7 +++----
 .../back.insert.iter.op++/pre.pass.cpp                     | 7 +++----
 .../back.insert.iter.op=/lv_value.pass.cpp                 | 7 +++----
 .../back.insert.iter.op=/rv_value.pass.cpp                 | 7 +++----
 .../back.insert.iter.op_astrk/test.pass.cpp                | 7 +++----
 .../back.insert.iter.ops/back.inserter/test.pass.cpp       | 7 +++----
 .../back.insert.iter.ops/nothing_to_do.pass.cpp            | 7 +++----
 .../insert.iterators/back.insert.iterator/types.pass.cpp   | 7 +++----
 .../front.insert.iter.cons/container.fail.cpp              | 7 +++----
 .../front.insert.iter.cons/container.pass.cpp              | 7 +++----
 .../front.insert.iter.op++/post.pass.cpp                   | 7 +++----
 .../front.insert.iter.op++/pre.pass.cpp                    | 7 +++----
 .../front.insert.iter.op=/lv_value.pass.cpp                | 7 +++----
 .../front.insert.iter.op=/rv_value.pass.cpp                | 7 +++----
 .../front.insert.iter.op_astrk/test.pass.cpp               | 7 +++----
 .../front.insert.iter.ops/front.inserter/test.pass.cpp     | 7 +++----
 .../front.insert.iter.ops/nothing_to_do.pass.cpp           | 7 +++----
 .../insert.iterators/front.insert.iterator/types.pass.cpp  | 7 +++----
 .../insert.iter.ops/insert.iter.cons/test.pass.cpp         | 7 +++----
 .../insert.iter.ops/insert.iter.op++/post.pass.cpp         | 7 +++----
 .../insert.iter.ops/insert.iter.op++/pre.pass.cpp          | 7 +++----
 .../insert.iter.ops/insert.iter.op=/lv_value.pass.cpp      | 7 +++----
 .../insert.iter.ops/insert.iter.op=/rv_value.pass.cpp      | 7 +++----
 .../insert.iter.ops/insert.iter.op_astrk/test.pass.cpp     | 7 +++----
 .../insert.iter.ops/inserter/test.pass.cpp                 | 7 +++----
 .../insert.iter.ops/nothing_to_do.pass.cpp                 | 7 +++----
 .../insert.iterators/insert.iterator/types.pass.cpp        | 7 +++----
 .../insert.iterators/nothing_to_do.pass.cpp                | 7 +++----
 .../move.iter.nonmember/make_move_iterator.pass.cpp        | 7 +++----
 .../move.iter.ops/move.iter.nonmember/minus.pass.cpp       | 7 +++----
 .../move.iter.ops/move.iter.nonmember/plus.pass.cpp        | 7 +++----
 .../move.iter.ops/move.iter.op.+/difference_type.pass.cpp  | 7 +++----
 .../move.iter.ops/move.iter.op.+=/difference_type.pass.cpp | 7 +++----
 .../move.iter.ops/move.iter.op.-/difference_type.pass.cpp  | 7 +++----
 .../move.iter.ops/move.iter.op.-=/difference_type.pass.cpp | 7 +++----
 .../move.iter.ops/move.iter.op.comp/op_eq.pass.cpp         | 7 +++----
 .../move.iter.ops/move.iter.op.comp/op_gt.pass.cpp         | 7 +++----
 .../move.iter.ops/move.iter.op.comp/op_gte.pass.cpp        | 7 +++----
 .../move.iter.ops/move.iter.op.comp/op_lt.pass.cpp         | 7 +++----
 .../move.iter.ops/move.iter.op.comp/op_lte.pass.cpp        | 7 +++----
 .../move.iter.ops/move.iter.op.comp/op_neq.pass.cpp        | 7 +++----
 .../move.iter.ops/move.iter.op.const/convert.fail.cpp      | 7 +++----
 .../move.iter.ops/move.iter.op.const/convert.pass.cpp      | 7 +++----
 .../move.iter.ops/move.iter.op.const/default.pass.cpp      | 7 +++----
 .../move.iter.ops/move.iter.op.const/iter.fail.cpp         | 7 +++----
 .../move.iter.ops/move.iter.op.const/iter.pass.cpp         | 7 +++----
 .../move.iter.op.conv/tested_elsewhere.pass.cpp            | 7 +++----
 .../move.iter.ops/move.iter.op.decr/post.pass.cpp          | 7 +++----
 .../move.iter.ops/move.iter.op.decr/pre.pass.cpp           | 7 +++----
 .../move.iter.ops/move.iter.op.incr/post.pass.cpp          | 7 +++----
 .../move.iter.ops/move.iter.op.incr/pre.pass.cpp           | 7 +++----
 .../move.iter.op.index/difference_type.pass.cpp            | 7 +++----
 .../move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp       | 7 +++----
 .../move.iter.ops/move.iter.op.star/op_star.pass.cpp       | 7 +++----
 .../move.iter.ops/move.iter.op=/move_iterator.fail.cpp     | 7 +++----
 .../move.iter.ops/move.iter.op=/move_iterator.pass.cpp     | 7 +++----
 .../move.iterators/move.iter.ops/nothing_to_do.pass.cpp    | 7 +++----
 .../move.iter.requirements/nothing_to_do.pass.cpp          | 7 +++----
 .../move.iterators/move.iterator/types.pass.cpp            | 7 +++----
 .../predef.iterators/move.iterators/nothing_to_do.pass.cpp | 7 +++----
 test/std/iterators/predef.iterators/nothing_to_do.pass.cpp | 7 +++----
 .../reverse.iterators/nothing_to_do.pass.cpp               | 7 +++----
 .../reverse.iter.ops/nothing_to_do.pass.cpp                | 7 +++----
 .../reverse.iter.ops/reverse.iter.cons/default.pass.cpp    | 7 +++----
 .../reverse.iter.ops/reverse.iter.cons/iter.fail.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.cons/iter.pass.cpp       | 7 +++----
 .../reverse.iter.cons/reverse_iterator.fail.cpp            | 7 +++----
 .../reverse.iter.cons/reverse_iterator.pass.cpp            | 7 +++----
 .../reverse.iter.conv/tested_elsewhere.pass.cpp            | 7 +++----
 .../reverse.iter.make/make_reverse_iterator.pass.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.op!=/test.pass.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.op++/post.pass.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.op++/pre.pass.cpp        | 7 +++----
 .../reverse.iter.op+/difference_type.pass.cpp              | 7 +++----
 .../reverse.iter.op+=/difference_type.pass.cpp             | 7 +++----
 .../reverse.iter.ops/reverse.iter.op--/post.pass.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.op--/pre.pass.cpp        | 7 +++----
 .../reverse.iter.op-/difference_type.pass.cpp              | 7 +++----
 .../reverse.iter.op-=/difference_type.pass.cpp             | 7 +++----
 .../reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp | 7 +++----
 .../reverse.iter.op=/reverse_iterator.fail.cpp             | 7 +++----
 .../reverse.iter.op=/reverse_iterator.pass.cpp             | 7 +++----
 .../reverse.iter.ops/reverse.iter.op==/test.pass.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp     | 7 +++----
 .../reverse.iter.ops/reverse.iter.opgt/test.pass.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp      | 7 +++----
 .../reverse.iter.opindex/difference_type.pass.cpp          | 7 +++----
 .../reverse.iter.ops/reverse.iter.oplt/test.pass.cpp       | 7 +++----
 .../reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp      | 7 +++----
 .../reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp  | 7 +++----
 .../reverse.iter.opsum/difference_type.pass.cpp            | 7 +++----
 .../reverse.iter.requirements/nothing_to_do.pass.cpp       | 7 +++----
 .../reverse.iterators/reverse.iterator/types.pass.cpp      | 7 +++----
 .../istream.iterator/istream.iterator.cons/copy.pass.cpp   | 7 +++----
 .../istream.iterator.cons/default.fail.cpp                 | 7 +++----
 .../istream.iterator.cons/default.pass.cpp                 | 7 +++----
 .../istream.iterator.cons/istream.pass.cpp                 | 7 +++----
 .../istream.iterator/istream.iterator.ops/arrow.pass.cpp   | 7 +++----
 .../istream.iterator.ops/dereference.pass.cpp              | 7 +++----
 .../istream.iterator/istream.iterator.ops/equal.pass.cpp   | 7 +++----
 .../istream.iterator.ops/post_increment.pass.cpp           | 7 +++----
 .../istream.iterator.ops/pre_increment.pass.cpp            | 7 +++----
 .../stream.iterators/istream.iterator/types.pass.cpp       | 7 +++----
 .../istreambuf.iterator.cons/default.pass.cpp              | 7 +++----
 .../istreambuf.iterator.cons/istream.pass.cpp              | 7 +++----
 .../istreambuf.iterator.cons/proxy.pass.cpp                | 7 +++----
 .../istreambuf.iterator.cons/streambuf.pass.cpp            | 7 +++----
 .../istreambuf.iterator_equal/equal.pass.cpp               | 7 +++----
 .../istreambuf.iterator_op!=/not_equal.pass.cpp            | 7 +++----
 .../istreambuf.iterator_op++/dereference.pass.cpp          | 7 +++----
 .../istreambuf.iterator_op==/equal.pass.cpp                | 7 +++----
 .../istreambuf.iterator_op_astrk/post_increment.pass.cpp   | 7 +++----
 .../istreambuf.iterator_op_astrk/pre_increment.pass.cpp    | 7 +++----
 .../istreambuf.iterator_proxy/proxy.pass.cpp               | 7 +++----
 .../stream.iterators/istreambuf.iterator/types.pass.cpp    | 7 +++----
 .../stream.iterators/iterator.range/begin_array.pass.cpp   | 7 +++----
 .../stream.iterators/iterator.range/begin_const.pass.cpp   | 7 +++----
 .../iterator.range/begin_non_const.pass.cpp                | 7 +++----
 .../stream.iterators/iterator.range/end_array.pass.cpp     | 7 +++----
 .../stream.iterators/iterator.range/end_const.pass.cpp     | 7 +++----
 .../stream.iterators/iterator.range/end_non_const.pass.cpp | 7 +++----
 test/std/iterators/stream.iterators/nothing_to_do.pass.cpp | 7 +++----
 .../ostream.iterator.cons.des/copy.pass.cpp                | 7 +++----
 .../ostream.iterator.cons.des/ostream.pass.cpp             | 7 +++----
 .../ostream.iterator.cons.des/ostream_delim.pass.cpp       | 7 +++----
 .../ostream.iterator.ops/assign_t.pass.cpp                 | 7 +++----
 .../ostream.iterator.ops/dereference.pass.cpp              | 7 +++----
 .../ostream.iterator.ops/increment.pass.cpp                | 7 +++----
 .../stream.iterators/ostream.iterator/types.pass.cpp       | 7 +++----
 .../ostreambuf.iter.cons/ostream.pass.cpp                  | 7 +++----
 .../ostreambuf.iter.cons/streambuf.pass.cpp                | 7 +++----
 .../ostreambuf.iter.ops/assign_c.pass.cpp                  | 7 +++----
 .../ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp | 7 +++----
 .../ostreambuf.iter.ops/failed.pass.cpp                    | 7 +++----
 .../ostreambuf.iter.ops/increment.pass.cpp                 | 7 +++----
 .../stream.iterators/ostreambuf.iterator/types.pass.cpp    | 7 +++----
 .../cmp/cmp.common/common_comparison_category.pass.cpp     | 7 +++----
 .../cmp/cmp.partialord/partialord.pass.cpp                 | 7 +++----
 .../cmp/cmp.strongeq/cmp.strongeq.pass.cpp                 | 7 +++----
 .../language.support/cmp/cmp.strongord/strongord.pass.cpp  | 7 +++----
 .../language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp    | 7 +++----
 test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp | 7 +++----
 .../language.support/cstdint/cstdint.syn/cstdint.pass.cpp  | 7 +++----
 test/std/language.support/nothing_to_do.pass.cpp           | 7 +++----
 .../language.support/support.dynamic/align_val_t.pass.cpp  | 7 +++----
 .../alloc.errors/bad.alloc/bad_alloc.pass.cpp              | 7 +++----
 .../new.badlength/bad_array_new_length.pass.cpp            | 7 +++----
 .../alloc.errors/new.handler/new_handler.pass.cpp          | 7 +++----
 .../support.dynamic/alloc.errors/nothing_to_do.pass.cpp    | 7 +++----
 .../alloc.errors/set.new.handler/get_new_handler.pass.cpp  | 7 +++----
 .../alloc.errors/set.new.handler/set_new_handler.pass.cpp  | 7 +++----
 .../new.delete.array/delete_align_val_t_replace.pass.cpp   | 7 +++----
 .../new.delete/new.delete.array/new_align_val_t.pass.cpp   | 7 +++----
 .../new.delete.array/new_align_val_t_nothrow.pass.cpp      | 7 +++----
 .../new_align_val_t_nothrow_replace.pass.cpp               | 7 +++----
 .../new.delete.array/new_align_val_t_replace.pass.cpp      | 7 +++----
 .../new.delete/new.delete.array/new_array.pass.cpp         | 7 +++----
 .../new.delete/new.delete.array/new_array_nothrow.pass.cpp | 7 +++----
 .../new.delete.array/new_array_nothrow_replace.pass.cpp    | 7 +++----
 .../new.delete/new.delete.array/new_array_replace.pass.cpp | 7 +++----
 .../new.delete/new.delete.array/new_size.sh.cpp            | 7 +++----
 .../new.delete/new.delete.array/new_size_align.sh.cpp      | 7 +++----
 .../new.delete.array/new_size_align_nothrow.sh.cpp         | 7 +++----
 .../new.delete/new.delete.array/new_size_nothrow.sh.cpp    | 7 +++----
 .../new.delete.array/sized_delete_array11.pass.cpp         | 7 +++----
 .../new.delete.array/sized_delete_array14.pass.cpp         | 7 +++----
 .../sized_delete_array_calls_unsized_delete_array.pass.cpp | 7 +++----
 .../sized_delete_array_fsizeddeallocation.sh.cpp           | 7 +++----
 .../new.delete/new.delete.dataraces/not_testable.pass.cpp  | 7 +++----
 .../new.delete/new.delete.placement/new.pass.cpp           | 7 +++----
 .../new.delete/new.delete.placement/new_array.pass.cpp     | 7 +++----
 .../new.delete/new.delete.placement/new_array_ptr.fail.cpp | 7 +++----
 .../new.delete/new.delete.placement/new_ptr.fail.cpp       | 7 +++----
 .../new.delete.single/delete_align_val_t_replace.pass.cpp  | 7 +++----
 .../new.delete/new.delete.single/new.pass.cpp              | 7 +++----
 .../new.delete/new.delete.single/new_align_val_t.pass.cpp  | 7 +++----
 .../new.delete.single/new_align_val_t_nothrow.pass.cpp     | 7 +++----
 .../new_align_val_t_nothrow_replace.pass.cpp               | 7 +++----
 .../new.delete.single/new_align_val_t_replace.pass.cpp     | 7 +++----
 .../new.delete/new.delete.single/new_nothrow.pass.cpp      | 7 +++----
 .../new.delete.single/new_nothrow_replace.pass.cpp         | 7 +++----
 .../new.delete/new.delete.single/new_replace.pass.cpp      | 7 +++----
 .../new.delete/new.delete.single/new_size.fail.cpp         | 7 +++----
 .../new.delete/new.delete.single/new_size_align.sh.cpp     | 7 +++----
 .../new.delete.single/new_size_align_nothrow.sh.cpp        | 7 +++----
 .../new.delete/new.delete.single/new_size_nothrow.fail.cpp | 7 +++----
 .../new.delete/new.delete.single/sized_delete11.pass.cpp   | 7 +++----
 .../new.delete/new.delete.single/sized_delete14.pass.cpp   | 7 +++----
 .../sized_delete_calls_unsized_delete.pass.cpp             | 7 +++----
 .../sized_delete_fsizeddeallocation.sh.cpp                 | 7 +++----
 .../support.dynamic/new.delete/nothing_to_do.pass.cpp      | 7 +++----
 .../support.dynamic/ptr.launder/launder.nodiscard.fail.cpp | 7 +++----
 .../support.dynamic/ptr.launder/launder.pass.cpp           | 7 +++----
 .../support.dynamic/ptr.launder/launder.types.fail.cpp     | 7 +++----
 .../support.exception/bad.exception/bad_exception.pass.cpp | 7 +++----
 .../support.exception/except.nested/assign.pass.cpp        | 7 +++----
 .../support.exception/except.nested/ctor_copy.pass.cpp     | 7 +++----
 .../support.exception/except.nested/ctor_default.pass.cpp  | 7 +++----
 .../except.nested/rethrow_if_nested.pass.cpp               | 7 +++----
 .../except.nested/rethrow_nested.pass.cpp                  | 7 +++----
 .../except.nested/throw_with_nested.pass.cpp               | 7 +++----
 .../exception.terminate/nothing_to_do.pass.cpp             | 7 +++----
 .../set.terminate/get_terminate.pass.cpp                   | 7 +++----
 .../set.terminate/set_terminate.pass.cpp                   | 7 +++----
 .../terminate.handler/terminate_handler.pass.cpp           | 7 +++----
 .../exception.terminate/terminate/terminate.pass.cpp       | 7 +++----
 .../support.exception/exception/exception.pass.cpp         | 7 +++----
 .../propagation/current_exception.pass.cpp                 | 7 +++----
 .../support.exception/propagation/exception_ptr.pass.cpp   | 7 +++----
 .../propagation/make_exception_ptr.pass.cpp                | 7 +++----
 .../propagation/rethrow_exception.pass.cpp                 | 7 +++----
 .../support.exception/uncaught/uncaught_exception.pass.cpp | 7 +++----
 .../uncaught/uncaught_exceptions.pass.cpp                  | 7 +++----
 .../support.general/nothing_to_do.pass.cpp                 | 7 +++----
 .../support.initlist/include_cxx03.pass.cpp                | 7 +++----
 .../support.initlist.access/access.pass.cpp                | 7 +++----
 .../support.initlist.cons/default.pass.cpp                 | 7 +++----
 .../support.initlist.range/begin_end.pass.cpp              | 7 +++----
 test/std/language.support/support.initlist/types.pass.cpp  | 7 +++----
 .../support.limits/c.limits/cfloat.pass.cpp                | 7 +++----
 .../support.limits/c.limits/climits.pass.cpp               | 7 +++----
 .../limits/denorm.style/check_values.pass.cpp              | 7 +++----
 .../support.limits/limits/is_specialized.pass.cpp          | 7 +++----
 .../numeric.limits.members/const_data_members.pass.cpp     | 7 +++----
 .../limits/numeric.limits.members/denorm_min.pass.cpp      | 7 +++----
 .../limits/numeric.limits.members/digits.pass.cpp          | 7 +++----
 .../limits/numeric.limits.members/digits10.pass.cpp        | 7 +++----
 .../limits/numeric.limits.members/epsilon.pass.cpp         | 7 +++----
 .../limits/numeric.limits.members/has_denorm.pass.cpp      | 7 +++----
 .../limits/numeric.limits.members/has_denorm_loss.pass.cpp | 7 +++----
 .../limits/numeric.limits.members/has_infinity.pass.cpp    | 7 +++----
 .../limits/numeric.limits.members/has_quiet_NaN.pass.cpp   | 7 +++----
 .../numeric.limits.members/has_signaling_NaN.pass.cpp      | 7 +++----
 .../limits/numeric.limits.members/infinity.pass.cpp        | 7 +++----
 .../limits/numeric.limits.members/is_bounded.pass.cpp      | 7 +++----
 .../limits/numeric.limits.members/is_exact.pass.cpp        | 7 +++----
 .../limits/numeric.limits.members/is_iec559.pass.cpp       | 7 +++----
 .../limits/numeric.limits.members/is_integer.pass.cpp      | 7 +++----
 .../limits/numeric.limits.members/is_modulo.pass.cpp       | 7 +++----
 .../limits/numeric.limits.members/is_signed.pass.cpp       | 7 +++----
 .../limits/numeric.limits.members/lowest.pass.cpp          | 7 +++----
 .../limits/numeric.limits.members/max.pass.cpp             | 7 +++----
 .../limits/numeric.limits.members/max_digits10.pass.cpp    | 7 +++----
 .../limits/numeric.limits.members/max_exponent.pass.cpp    | 7 +++----
 .../limits/numeric.limits.members/max_exponent10.pass.cpp  | 7 +++----
 .../limits/numeric.limits.members/min.pass.cpp             | 7 +++----
 .../limits/numeric.limits.members/min_exponent.pass.cpp    | 7 +++----
 .../limits/numeric.limits.members/min_exponent10.pass.cpp  | 7 +++----
 .../limits/numeric.limits.members/quiet_NaN.pass.cpp       | 7 +++----
 .../limits/numeric.limits.members/radix.pass.cpp           | 7 +++----
 .../limits/numeric.limits.members/round_error.pass.cpp     | 7 +++----
 .../limits/numeric.limits.members/round_style.pass.cpp     | 7 +++----
 .../limits/numeric.limits.members/signaling_NaN.pass.cpp   | 7 +++----
 .../limits/numeric.limits.members/tinyness_before.pass.cpp | 7 +++----
 .../limits/numeric.limits.members/traps.pass.cpp           | 7 +++----
 .../support.limits/limits/numeric.limits/default.pass.cpp  | 7 +++----
 .../limits/numeric.special/nothing_to_do.pass.cpp          | 7 +++----
 .../limits/round.style/check_values.pass.cpp               | 7 +++----
 .../language.support/support.limits/nothing_to_do.pass.cpp | 7 +++----
 .../support.limits.general/algorithm.version.pass.cpp      | 7 +++----
 .../support.limits.general/any.version.pass.cpp            | 7 +++----
 .../support.limits.general/array.version.pass.cpp          | 7 +++----
 .../support.limits.general/atomic.version.pass.cpp         | 7 +++----
 .../support.limits.general/bit.version.pass.cpp            | 7 +++----
 .../support.limits.general/charconv.pass.cpp               | 7 +++----
 .../support.limits.general/chrono.version.pass.cpp         | 7 +++----
 .../support.limits.general/cmath.version.pass.cpp          | 7 +++----
 .../support.limits.general/compare.version.pass.cpp        | 7 +++----
 .../support.limits.general/complex.version.pass.cpp        | 7 +++----
 .../support.limits.general/concepts.version.pass.cpp       | 7 +++----
 .../support.limits.general/cstddef.version.pass.cpp        | 7 +++----
 .../support.limits.general/deque.version.pass.cpp          | 7 +++----
 .../support.limits.general/exception.version.pass.cpp      | 7 +++----
 .../support.limits.general/execution.version.pass.cpp      | 7 +++----
 .../support.limits.general/filesystem.version.pass.cpp     | 7 +++----
 .../support.limits.general/forward_list.version.pass.cpp   | 7 +++----
 .../support.limits.general/functional.version.pass.cpp     | 7 +++----
 .../generate_feature_test_macro_components.py              | 7 +++----
 .../support.limits.general/iomanip.version.pass.cpp        | 7 +++----
 .../support.limits.general/istream.version.pass.cpp        | 7 +++----
 .../support.limits.general/iterator.version.pass.cpp       | 7 +++----
 .../support.limits.general/limits.version.pass.cpp         | 7 +++----
 .../support.limits.general/list.version.pass.cpp           | 7 +++----
 .../support.limits.general/locale.version.pass.cpp         | 7 +++----
 .../support.limits.general/map.version.pass.cpp            | 7 +++----
 .../support.limits.general/memory.version.pass.cpp         | 7 +++----
 .../memory_resource.version.pass.cpp                       | 7 +++----
 .../support.limits.general/mutex.version.pass.cpp          | 7 +++----
 .../support.limits.general/new.version.pass.cpp            | 7 +++----
 .../support.limits.general/numeric.version.pass.cpp        | 7 +++----
 .../support.limits.general/optional.version.pass.cpp       | 7 +++----
 .../support.limits.general/ostream.version.pass.cpp        | 7 +++----
 .../support.limits.general/regex.version.pass.cpp          | 7 +++----
 .../scoped_allocator.version.pass.cpp                      | 7 +++----
 .../support.limits.general/set.version.pass.cpp            | 7 +++----
 .../support.limits.general/shared_mutex.version.pass.cpp   | 7 +++----
 .../support.limits.general/string.version.pass.cpp         | 7 +++----
 .../support.limits.general/string_view.version.pass.cpp    | 7 +++----
 .../support.limits.general/tuple.version.pass.cpp          | 7 +++----
 .../support.limits.general/type_traits.version.pass.cpp    | 7 +++----
 .../support.limits.general/unordered_map.version.pass.cpp  | 7 +++----
 .../support.limits.general/unordered_set.version.pass.cpp  | 7 +++----
 .../support.limits.general/utility.version.pass.cpp        | 7 +++----
 .../support.limits.general/variant.version.pass.cpp        | 7 +++----
 .../support.limits.general/vector.version.pass.cpp         | 7 +++----
 .../support.limits.general/version.version.pass.cpp        | 7 +++----
 test/std/language.support/support.limits/version.pass.cpp  | 7 +++----
 .../support.rtti/bad.cast/bad_cast.pass.cpp                | 7 +++----
 .../support.rtti/bad.typeid/bad_typeid.pass.cpp            | 7 +++----
 .../support.rtti/type.info/type_info.pass.cpp              | 7 +++----
 .../support.rtti/type.info/type_info_hash.pass.cpp         | 7 +++----
 test/std/language.support/support.runtime/csetjmp.pass.cpp | 7 +++----
 test/std/language.support/support.runtime/csignal.pass.cpp | 7 +++----
 test/std/language.support/support.runtime/cstdarg.pass.cpp | 7 +++----
 .../std/language.support/support.runtime/cstdbool.pass.cpp | 7 +++----
 test/std/language.support/support.runtime/cstdlib.pass.cpp | 7 +++----
 test/std/language.support/support.runtime/ctime.pass.cpp   | 7 +++----
 .../support.start.term/quick_exit.pass.cpp                 | 7 +++----
 .../support.start.term/quick_exit_check1.fail.cpp          | 7 +++----
 .../support.start.term/quick_exit_check2.fail.cpp          | 7 +++----
 test/std/language.support/support.types/byte.pass.cpp      | 7 +++----
 .../support.types/byteops/and.assign.pass.cpp              | 7 +++----
 .../language.support/support.types/byteops/and.pass.cpp    | 7 +++----
 .../support.types/byteops/enum_direct_init.pass.cpp        | 7 +++----
 .../support.types/byteops/lshift.assign.fail.cpp           | 7 +++----
 .../support.types/byteops/lshift.assign.pass.cpp           | 7 +++----
 .../language.support/support.types/byteops/lshift.fail.cpp | 7 +++----
 .../language.support/support.types/byteops/lshift.pass.cpp | 7 +++----
 .../language.support/support.types/byteops/not.pass.cpp    | 7 +++----
 .../support.types/byteops/or.assign.pass.cpp               | 7 +++----
 .../std/language.support/support.types/byteops/or.pass.cpp | 7 +++----
 .../support.types/byteops/rshift.assign.fail.cpp           | 7 +++----
 .../support.types/byteops/rshift.assign.pass.cpp           | 7 +++----
 .../language.support/support.types/byteops/rshift.fail.cpp | 7 +++----
 .../language.support/support.types/byteops/rshift.pass.cpp | 7 +++----
 .../support.types/byteops/to_integer.fail.cpp              | 7 +++----
 .../support.types/byteops/to_integer.pass.cpp              | 7 +++----
 .../support.types/byteops/xor.assign.pass.cpp              | 7 +++----
 .../language.support/support.types/byteops/xor.pass.cpp    | 7 +++----
 .../language.support/support.types/max_align_t.pass.cpp    | 7 +++----
 test/std/language.support/support.types/null.pass.cpp      | 7 +++----
 test/std/language.support/support.types/nullptr_t.pass.cpp | 7 +++----
 .../support.types/nullptr_t_integral_cast.fail.cpp         | 7 +++----
 .../support.types/nullptr_t_integral_cast.pass.cpp         | 7 +++----
 test/std/language.support/support.types/offsetof.pass.cpp  | 7 +++----
 test/std/language.support/support.types/ptrdiff_t.pass.cpp | 7 +++----
 test/std/language.support/support.types/size_t.pass.cpp    | 7 +++----
 test/std/localization/c.locales/clocale.pass.cpp           | 7 +++----
 .../locale.collate.byname/compare.pass.cpp                 | 7 +++----
 .../category.collate/locale.collate.byname/hash.pass.cpp   | 7 +++----
 .../locale.collate.byname/transform.pass.cpp               | 7 +++----
 .../category.collate/locale.collate.byname/types.pass.cpp  | 7 +++----
 .../category.collate/locale.collate/ctor.pass.cpp          | 7 +++----
 .../locale.collate/locale.collate.members/compare.pass.cpp | 7 +++----
 .../locale.collate/locale.collate.members/hash.pass.cpp    | 7 +++----
 .../locale.collate.members/transform.pass.cpp              | 7 +++----
 .../locale.collate.virtuals/tested_elsewhere.pass.cpp      | 7 +++----
 .../category.collate/locale.collate/types.pass.cpp         | 7 +++----
 .../category.collate/nothing_to_do.pass.cpp                | 7 +++----
 .../locale.categories/category.ctype/ctype_base.pass.cpp   | 7 +++----
 .../facet.ctype.char.dtor/dtor.pass.cpp                    | 7 +++----
 .../facet.ctype.char.members/ctor.pass.cpp                 | 7 +++----
 .../facet.ctype.char.members/is_1.pass.cpp                 | 7 +++----
 .../facet.ctype.char.members/is_many.pass.cpp              | 7 +++----
 .../facet.ctype.char.members/narrow_1.pass.cpp             | 7 +++----
 .../facet.ctype.char.members/narrow_many.pass.cpp          | 7 +++----
 .../facet.ctype.char.members/scan_is.pass.cpp              | 7 +++----
 .../facet.ctype.char.members/scan_not.pass.cpp             | 7 +++----
 .../facet.ctype.char.members/table.pass.cpp                | 7 +++----
 .../facet.ctype.char.members/tolower_1.pass.cpp            | 7 +++----
 .../facet.ctype.char.members/tolower_many.pass.cpp         | 7 +++----
 .../facet.ctype.char.members/toupper_1.pass.cpp            | 7 +++----
 .../facet.ctype.char.members/toupper_many.pass.cpp         | 7 +++----
 .../facet.ctype.char.members/widen_1.pass.cpp              | 7 +++----
 .../facet.ctype.char.members/widen_many.pass.cpp           | 7 +++----
 .../facet.ctype.char.statics/classic_table.pass.cpp        | 7 +++----
 .../facet.ctype.char.virtuals/tested_elsewhere.pass.cpp    | 7 +++----
 .../category.ctype/facet.ctype.special/types.pass.cpp      | 7 +++----
 .../locale.codecvt.byname/ctor_char.pass.cpp               | 7 +++----
 .../locale.codecvt.byname/ctor_char16_t.pass.cpp           | 7 +++----
 .../locale.codecvt.byname/ctor_char32_t.pass.cpp           | 7 +++----
 .../locale.codecvt.byname/ctor_wchar_t.pass.cpp            | 7 +++----
 .../category.ctype/locale.codecvt/codecvt_base.pass.cpp    | 7 +++----
 .../category.ctype/locale.codecvt/ctor_char.pass.cpp       | 7 +++----
 .../category.ctype/locale.codecvt/ctor_char16_t.pass.cpp   | 7 +++----
 .../category.ctype/locale.codecvt/ctor_char32_t.pass.cpp   | 7 +++----
 .../category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp    | 7 +++----
 .../locale.codecvt.members/char16_t_always_noconv.pass.cpp | 7 +++----
 .../locale.codecvt.members/char16_t_encoding.pass.cpp      | 7 +++----
 .../locale.codecvt.members/char16_t_in.pass.cpp            | 7 +++----
 .../locale.codecvt.members/char16_t_length.pass.cpp        | 7 +++----
 .../locale.codecvt.members/char16_t_max_length.pass.cpp    | 7 +++----
 .../locale.codecvt.members/char16_t_out.pass.cpp           | 7 +++----
 .../locale.codecvt.members/char16_t_unshift.pass.cpp       | 7 +++----
 .../locale.codecvt.members/char32_t_always_noconv.pass.cpp | 7 +++----
 .../locale.codecvt.members/char32_t_encoding.pass.cpp      | 7 +++----
 .../locale.codecvt.members/char32_t_in.pass.cpp            | 7 +++----
 .../locale.codecvt.members/char32_t_length.pass.cpp        | 7 +++----
 .../locale.codecvt.members/char32_t_max_length.pass.cpp    | 7 +++----
 .../locale.codecvt.members/char32_t_out.pass.cpp           | 7 +++----
 .../locale.codecvt.members/char32_t_unshift.pass.cpp       | 7 +++----
 .../locale.codecvt.members/char_always_noconv.pass.cpp     | 7 +++----
 .../locale.codecvt.members/char_encoding.pass.cpp          | 7 +++----
 .../locale.codecvt/locale.codecvt.members/char_in.pass.cpp | 7 +++----
 .../locale.codecvt.members/char_length.pass.cpp            | 7 +++----
 .../locale.codecvt.members/char_max_length.pass.cpp        | 7 +++----
 .../locale.codecvt.members/char_out.pass.cpp               | 7 +++----
 .../locale.codecvt.members/char_unshift.pass.cpp           | 7 +++----
 .../locale.codecvt.members/utf_sanity_check.pass.cpp       | 7 +++----
 .../locale.codecvt.members/wchar_t_always_noconv.pass.cpp  | 7 +++----
 .../locale.codecvt.members/wchar_t_encoding.pass.cpp       | 7 +++----
 .../locale.codecvt.members/wchar_t_in.pass.cpp             | 7 +++----
 .../locale.codecvt.members/wchar_t_length.pass.cpp         | 7 +++----
 .../locale.codecvt.members/wchar_t_max_length.pass.cpp     | 7 +++----
 .../locale.codecvt.members/wchar_t_out.pass.cpp            | 7 +++----
 .../locale.codecvt.members/wchar_t_unshift.pass.cpp        | 7 +++----
 .../locale.codecvt.virtuals/tested_elsewhere.pass.cpp      | 7 +++----
 .../category.ctype/locale.codecvt/types_char.pass.cpp      | 7 +++----
 .../category.ctype/locale.codecvt/types_char16_t.pass.cpp  | 7 +++----
 .../category.ctype/locale.codecvt/types_char32_t.pass.cpp  | 7 +++----
 .../category.ctype/locale.codecvt/types_wchar_t.pass.cpp   | 7 +++----
 .../category.ctype/locale.ctype.byname/is_1.pass.cpp       | 7 +++----
 .../category.ctype/locale.ctype.byname/is_many.pass.cpp    | 7 +++----
 .../category.ctype/locale.ctype.byname/mask.pass.cpp       | 7 +++----
 .../category.ctype/locale.ctype.byname/narrow_1.pass.cpp   | 7 +++----
 .../locale.ctype.byname/narrow_many.pass.cpp               | 7 +++----
 .../category.ctype/locale.ctype.byname/scan_is.pass.cpp    | 7 +++----
 .../category.ctype/locale.ctype.byname/scan_not.pass.cpp   | 7 +++----
 .../category.ctype/locale.ctype.byname/tolower_1.pass.cpp  | 7 +++----
 .../locale.ctype.byname/tolower_many.pass.cpp              | 7 +++----
 .../category.ctype/locale.ctype.byname/toupper_1.pass.cpp  | 7 +++----
 .../locale.ctype.byname/toupper_many.pass.cpp              | 7 +++----
 .../category.ctype/locale.ctype.byname/types.pass.cpp      | 7 +++----
 .../category.ctype/locale.ctype.byname/widen_1.pass.cpp    | 7 +++----
 .../category.ctype/locale.ctype.byname/widen_many.pass.cpp | 7 +++----
 .../category.ctype/locale.ctype/ctor.pass.cpp              | 7 +++----
 .../locale.ctype/locale.ctype.members/is_1.pass.cpp        | 7 +++----
 .../locale.ctype/locale.ctype.members/is_many.pass.cpp     | 7 +++----
 .../locale.ctype/locale.ctype.members/narrow_1.pass.cpp    | 7 +++----
 .../locale.ctype/locale.ctype.members/narrow_many.pass.cpp | 7 +++----
 .../locale.ctype/locale.ctype.members/scan_is.pass.cpp     | 7 +++----
 .../locale.ctype/locale.ctype.members/scan_not.pass.cpp    | 7 +++----
 .../locale.ctype/locale.ctype.members/tolower_1.pass.cpp   | 7 +++----
 .../locale.ctype.members/tolower_many.pass.cpp             | 7 +++----
 .../locale.ctype/locale.ctype.members/toupper_1.pass.cpp   | 7 +++----
 .../locale.ctype.members/toupper_many.pass.cpp             | 7 +++----
 .../locale.ctype/locale.ctype.members/widen_1.pass.cpp     | 7 +++----
 .../locale.ctype/locale.ctype.members/widen_many.pass.cpp  | 7 +++----
 .../locale.ctype.virtuals/tested_elsewhere.pass.cpp        | 7 +++----
 .../category.ctype/locale.ctype/types.pass.cpp             | 7 +++----
 .../locale.messages.byname/nothing_to_do.pass.cpp          | 7 +++----
 .../category.messages/locale.messages/ctor.pass.cpp        | 7 +++----
 .../locale.messages.members/not_testable.pass.cpp          | 7 +++----
 .../locale.messages.virtuals/tested_elsewhere.pass.cpp     | 7 +++----
 .../locale.messages/messages_base.pass.cpp                 | 7 +++----
 .../category.messages/locale.messages/types.pass.cpp       | 7 +++----
 .../category.messages/nothing_to_do.pass.cpp               | 7 +++----
 .../category.monetary/locale.money.get/ctor.pass.cpp       | 7 +++----
 .../get_long_double_en_US.pass.cpp                         | 7 +++----
 .../get_long_double_fr_FR.pass.cpp                         | 7 +++----
 .../get_long_double_ru_RU.pass.cpp                         | 7 +++----
 .../get_long_double_zh_CN.pass.cpp                         | 7 +++----
 .../locale.money.get.members/get_string_en_US.pass.cpp     | 7 +++----
 .../locale.money.get.virtuals/tested_elsewhere.pass.cpp    | 7 +++----
 .../category.monetary/locale.money.get/types.pass.cpp      | 7 +++----
 .../category.monetary/locale.money.put/ctor.pass.cpp       | 7 +++----
 .../put_long_double_en_US.pass.cpp                         | 7 +++----
 .../put_long_double_fr_FR.pass.cpp                         | 7 +++----
 .../put_long_double_ru_RU.pass.cpp                         | 7 +++----
 .../put_long_double_zh_CN.pass.cpp                         | 7 +++----
 .../locale.money.put.members/put_string_en_US.pass.cpp     | 7 +++----
 .../locale.money.put.virtuals/tested_elsewhere.pass.cpp    | 7 +++----
 .../category.monetary/locale.money.put/types.pass.cpp      | 7 +++----
 .../locale.moneypunct.byname/curr_symbol.pass.cpp          | 7 +++----
 .../locale.moneypunct.byname/decimal_point.pass.cpp        | 7 +++----
 .../locale.moneypunct.byname/frac_digits.pass.cpp          | 7 +++----
 .../locale.moneypunct.byname/grouping.pass.cpp             | 7 +++----
 .../locale.moneypunct.byname/neg_format.pass.cpp           | 7 +++----
 .../locale.moneypunct.byname/negative_sign.pass.cpp        | 7 +++----
 .../locale.moneypunct.byname/pos_format.pass.cpp           | 7 +++----
 .../locale.moneypunct.byname/positive_sign.pass.cpp        | 7 +++----
 .../locale.moneypunct.byname/thousands_sep.pass.cpp        | 7 +++----
 .../category.monetary/locale.moneypunct/ctor.pass.cpp      | 7 +++----
 .../locale.moneypunct.members/curr_symbol.pass.cpp         | 7 +++----
 .../locale.moneypunct.members/decimal_point.pass.cpp       | 7 +++----
 .../locale.moneypunct.members/frac_digits.pass.cpp         | 7 +++----
 .../locale.moneypunct.members/grouping.pass.cpp            | 7 +++----
 .../locale.moneypunct.members/neg_format.pass.cpp          | 7 +++----
 .../locale.moneypunct.members/negative_sign.pass.cpp       | 7 +++----
 .../locale.moneypunct.members/pos_format.pass.cpp          | 7 +++----
 .../locale.moneypunct.members/positive_sign.pass.cpp       | 7 +++----
 .../locale.moneypunct.members/thousands_sep.pass.cpp       | 7 +++----
 .../locale.moneypunct.virtuals/tested_elsewhere.pass.cpp   | 7 +++----
 .../locale.moneypunct/money_base.pass.cpp                  | 7 +++----
 .../category.monetary/locale.moneypunct/types.pass.cpp     | 7 +++----
 .../category.monetary/nothing_to_do.pass.cpp               | 7 +++----
 .../category.numeric/locale.nm.put/ctor.pass.cpp           | 7 +++----
 .../locale.nm.put/facet.num.put.members/put_bool.pass.cpp  | 7 +++----
 .../facet.num.put.members/put_double.pass.cpp              | 7 +++----
 .../locale.nm.put/facet.num.put.members/put_long.pass.cpp  | 7 +++----
 .../facet.num.put.members/put_long_double.pass.cpp         | 7 +++----
 .../facet.num.put.members/put_long_long.pass.cpp           | 7 +++----
 .../facet.num.put.members/put_pointer.pass.cpp             | 7 +++----
 .../facet.num.put.members/put_unsigned_long.pass.cpp       | 7 +++----
 .../facet.num.put.members/put_unsigned_long_long.pass.cpp  | 7 +++----
 .../facet.num.put.virtuals/tested_elsewhere.pass.cpp       | 7 +++----
 .../category.numeric/locale.nm.put/types.pass.cpp          | 7 +++----
 .../category.numeric/locale.num.get/ctor.pass.cpp          | 7 +++----
 .../locale.num.get/facet.num.get.members/get_bool.pass.cpp | 7 +++----
 .../facet.num.get.members/get_double.pass.cpp              | 7 +++----
 .../facet.num.get.members/get_float.pass.cpp               | 7 +++----
 .../locale.num.get/facet.num.get.members/get_long.pass.cpp | 7 +++----
 .../facet.num.get.members/get_long_double.pass.cpp         | 7 +++----
 .../facet.num.get.members/get_long_long.pass.cpp           | 7 +++----
 .../facet.num.get.members/get_pointer.pass.cpp             | 7 +++----
 .../facet.num.get.members/get_unsigned_int.pass.cpp        | 7 +++----
 .../facet.num.get.members/get_unsigned_long.pass.cpp       | 7 +++----
 .../facet.num.get.members/get_unsigned_long_long.pass.cpp  | 7 +++----
 .../facet.num.get.members/get_unsigned_short.pass.cpp      | 7 +++----
 .../facet.num.get.members/test_min_max.pass.cpp            | 7 +++----
 .../facet.num.get.members/test_neg_one.pass.cpp            | 7 +++----
 .../facet.num.get.virtuals/tested_elsewhere.pass.cpp       | 7 +++----
 .../category.numeric/locale.num.get/types.pass.cpp         | 7 +++----
 .../category.numeric/nothing_to_do.pass.cpp                | 7 +++----
 .../locale.time.get.byname/date_order.pass.cpp             | 7 +++----
 .../locale.time.get.byname/date_order_wide.pass.cpp        | 7 +++----
 .../category.time/locale.time.get.byname/get_date.pass.cpp | 7 +++----
 .../locale.time.get.byname/get_date_wide.pass.cpp          | 7 +++----
 .../locale.time.get.byname/get_monthname.pass.cpp          | 7 +++----
 .../locale.time.get.byname/get_monthname_wide.pass.cpp     | 7 +++----
 .../category.time/locale.time.get.byname/get_one.pass.cpp  | 7 +++----
 .../locale.time.get.byname/get_one_wide.pass.cpp           | 7 +++----
 .../category.time/locale.time.get.byname/get_time.pass.cpp | 7 +++----
 .../locale.time.get.byname/get_time_wide.pass.cpp          | 7 +++----
 .../locale.time.get.byname/get_weekday.pass.cpp            | 7 +++----
 .../locale.time.get.byname/get_weekday_wide.pass.cpp       | 7 +++----
 .../category.time/locale.time.get.byname/get_year.pass.cpp | 7 +++----
 .../locale.time.get.byname/get_year_wide.pass.cpp          | 7 +++----
 .../category.time/locale.time.get/ctor.pass.cpp            | 7 +++----
 .../locale.time.get.members/date_order.pass.cpp            | 7 +++----
 .../locale.time.get.members/get_date.pass.cpp              | 7 +++----
 .../locale.time.get.members/get_date_wide.pass.cpp         | 7 +++----
 .../locale.time.get.members/get_many.pass.cpp              | 7 +++----
 .../locale.time.get.members/get_monthname.pass.cpp         | 7 +++----
 .../locale.time.get.members/get_monthname_wide.pass.cpp    | 7 +++----
 .../locale.time.get.members/get_one.pass.cpp               | 7 +++----
 .../locale.time.get.members/get_time.pass.cpp              | 7 +++----
 .../locale.time.get.members/get_time_wide.pass.cpp         | 7 +++----
 .../locale.time.get.members/get_weekday.pass.cpp           | 7 +++----
 .../locale.time.get.members/get_weekday_wide.pass.cpp      | 7 +++----
 .../locale.time.get.members/get_year.pass.cpp              | 7 +++----
 .../locale.time.get.virtuals/tested_elsewhere.pass.cpp     | 7 +++----
 .../category.time/locale.time.get/time_base.pass.cpp       | 7 +++----
 .../category.time/locale.time.get/types.pass.cpp           | 7 +++----
 .../category.time/locale.time.put.byname/put1.pass.cpp     | 7 +++----
 .../category.time/locale.time.put/ctor.pass.cpp            | 7 +++----
 .../locale.time.put/locale.time.put.members/put1.pass.cpp  | 7 +++----
 .../locale.time.put/locale.time.put.members/put2.pass.cpp  | 7 +++----
 .../locale.time.put.virtuals/tested_elsewhere.pass.cpp     | 7 +++----
 .../category.time/locale.time.put/types.pass.cpp           | 7 +++----
 .../locale.categories/category.time/nothing_to_do.pass.cpp | 7 +++----
 .../locale.numpunct.byname/decimal_point.pass.cpp          | 7 +++----
 .../locale.numpunct.byname/grouping.pass.cpp               | 7 +++----
 .../locale.numpunct.byname/thousands_sep.pass.cpp          | 7 +++----
 .../facet.numpunct/locale.numpunct/ctor.pass.cpp           | 7 +++----
 .../facet.numpunct.members/decimal_point.pass.cpp          | 7 +++----
 .../facet.numpunct.members/falsename.pass.cpp              | 7 +++----
 .../facet.numpunct.members/grouping.pass.cpp               | 7 +++----
 .../facet.numpunct.members/thousands_sep.pass.cpp          | 7 +++----
 .../facet.numpunct.members/truename.pass.cpp               | 7 +++----
 .../facet.numpunct.virtuals/tested_elsewhere.pass.cpp      | 7 +++----
 .../facet.numpunct/locale.numpunct/types.pass.cpp          | 7 +++----
 .../facet.numpunct/nothing_to_do.pass.cpp                  | 7 +++----
 .../facets.examples/nothing_to_do.pass.cpp                 | 7 +++----
 test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp  | 7 +++----
 test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp | 7 +++----
 .../locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp     | 7 +++----
 .../locale.stdcvt/codecvt_utf16_encoding.pass.cpp          | 7 +++----
 .../localization/locale.stdcvt/codecvt_utf16_in.pass.cpp   | 7 +++----
 .../locale.stdcvt/codecvt_utf16_length.pass.cpp            | 7 +++----
 .../locale.stdcvt/codecvt_utf16_max_length.pass.cpp        | 7 +++----
 .../localization/locale.stdcvt/codecvt_utf16_out.pass.cpp  | 7 +++----
 .../locale.stdcvt/codecvt_utf16_unshift.pass.cpp           | 7 +++----
 test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp  | 7 +++----
 .../locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp      | 7 +++----
 .../locale.stdcvt/codecvt_utf8_encoding.pass.cpp           | 7 +++----
 .../localization/locale.stdcvt/codecvt_utf8_in.pass.cpp    | 7 +++----
 .../locale.stdcvt/codecvt_utf8_length.pass.cpp             | 7 +++----
 .../locale.stdcvt/codecvt_utf8_max_length.pass.cpp         | 7 +++----
 .../localization/locale.stdcvt/codecvt_utf8_out.pass.cpp   | 7 +++----
 .../locale.stdcvt/codecvt_utf8_unshift.pass.cpp            | 7 +++----
 .../codecvt_utf8_utf16_always_noconv.pass.cpp              | 7 +++----
 .../locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp     | 7 +++----
 .../locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp           | 7 +++----
 .../locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp       | 7 +++----
 .../locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp   | 7 +++----
 .../locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp          | 7 +++----
 .../locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp      | 7 +++----
 test/std/localization/locale.syn/nothing_to_do.pass.cpp    | 7 +++----
 .../locale.convenience/classification/isalnum.pass.cpp     | 7 +++----
 .../locale.convenience/classification/isalpha.pass.cpp     | 7 +++----
 .../locale.convenience/classification/iscntrl.pass.cpp     | 7 +++----
 .../locale.convenience/classification/isdigit.pass.cpp     | 7 +++----
 .../locale.convenience/classification/isgraph.pass.cpp     | 7 +++----
 .../locale.convenience/classification/islower.pass.cpp     | 7 +++----
 .../locale.convenience/classification/isprint.pass.cpp     | 7 +++----
 .../locale.convenience/classification/ispunct.pass.cpp     | 7 +++----
 .../locale.convenience/classification/isspace.pass.cpp     | 7 +++----
 .../locale.convenience/classification/isupper.pass.cpp     | 7 +++----
 .../locale.convenience/classification/isxdigit.pass.cpp    | 7 +++----
 .../conversions/conversions.buffer/ctor.pass.cpp           | 7 +++----
 .../conversions/conversions.buffer/overflow.pass.cpp       | 7 +++----
 .../conversions/conversions.buffer/pbackfail.pass.cpp      | 7 +++----
 .../conversions/conversions.buffer/rdbuf.pass.cpp          | 7 +++----
 .../conversions/conversions.buffer/seekoff.pass.cpp        | 7 +++----
 .../conversions/conversions.buffer/state.pass.cpp          | 7 +++----
 .../conversions/conversions.buffer/test.pass.cpp           | 7 +++----
 .../conversions/conversions.buffer/underflow.pass.cpp      | 7 +++----
 .../conversions/conversions.character/tolower.pass.cpp     | 7 +++----
 .../conversions/conversions.character/toupper.pass.cpp     | 7 +++----
 .../conversions/conversions.string/converted.pass.cpp      | 7 +++----
 .../conversions/conversions.string/ctor_codecvt.pass.cpp   | 7 +++----
 .../conversions.string/ctor_codecvt_state.pass.cpp         | 7 +++----
 .../conversions/conversions.string/ctor_copy.pass.cpp      | 7 +++----
 .../conversions.string/ctor_err_string.pass.cpp            | 7 +++----
 .../conversions/conversions.string/from_bytes.pass.cpp     | 7 +++----
 .../conversions/conversions.string/state.pass.cpp          | 7 +++----
 .../conversions/conversions.string/to_bytes.pass.cpp       | 7 +++----
 .../conversions/conversions.string/types.pass.cpp          | 7 +++----
 .../locale.convenience/conversions/nothing_to_do.pass.cpp  | 7 +++----
 .../locales/locale.convenience/nothing_to_do.pass.cpp      | 7 +++----
 .../locales/locale.global.templates/has_facet.pass.cpp     | 7 +++----
 .../locales/locale.global.templates/use_facet.pass.cpp     | 7 +++----
 .../locales/locale/locale.cons/assign.pass.cpp             | 7 +++----
 .../locales/locale/locale.cons/char_pointer.pass.cpp       | 7 +++----
 .../localization/locales/locale/locale.cons/copy.pass.cpp  | 7 +++----
 .../locales/locale/locale.cons/default.pass.cpp            | 7 +++----
 .../locale/locale.cons/locale_char_pointer_cat.pass.cpp    | 7 +++----
 .../locales/locale/locale.cons/locale_facetptr.pass.cpp    | 7 +++----
 .../locales/locale/locale.cons/locale_locale_cat.pass.cpp  | 7 +++----
 .../locales/locale/locale.cons/locale_string_cat.pass.cpp  | 7 +++----
 .../locales/locale/locale.cons/string.pass.cpp             | 7 +++----
 .../locales/locale/locale.members/combine.pass.cpp         | 7 +++----
 .../locales/locale/locale.members/name.pass.cpp            | 7 +++----
 .../locales/locale/locale.operators/compare.pass.cpp       | 7 +++----
 .../locales/locale/locale.operators/eq.pass.cpp            | 7 +++----
 .../locales/locale/locale.statics/classic.pass.cpp         | 7 +++----
 .../locales/locale/locale.statics/global.pass.cpp          | 7 +++----
 .../locale/locale.types/locale.category/category.pass.cpp  | 7 +++----
 .../locale.types/locale.facet/tested_elsewhere.pass.cpp    | 7 +++----
 .../locale.types/locale.id/tested_elsewhere.pass.cpp       | 7 +++----
 .../locales/locale/locale.types/nothing_to_do.pass.cpp     | 7 +++----
 .../std/localization/locales/locale/nothing_to_do.pass.cpp | 7 +++----
 test/std/localization/locales/nothing_to_do.pass.cpp       | 7 +++----
 .../localization.general/nothing_to_do.pass.cpp            | 7 +++----
 test/std/nothing_to_do.pass.cpp                            | 7 +++----
 test/std/numerics/c.math/cmath.pass.cpp                    | 7 +++----
 test/std/numerics/c.math/ctgmath.pass.cpp                  | 7 +++----
 test/std/numerics/c.math/tgmath_h.pass.cpp                 | 7 +++----
 test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp           | 7 +++----
 test/std/numerics/complex.number/cases.h                   | 7 +++----
 test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp  | 7 +++----
 .../complex.number/cmplx.over/UDT_is_rejected.fail.cpp     | 7 +++----
 test/std/numerics/complex.number/cmplx.over/arg.pass.cpp   | 7 +++----
 test/std/numerics/complex.number/cmplx.over/conj.pass.cpp  | 7 +++----
 test/std/numerics/complex.number/cmplx.over/imag.pass.cpp  | 7 +++----
 test/std/numerics/complex.number/cmplx.over/norm.pass.cpp  | 7 +++----
 test/std/numerics/complex.number/cmplx.over/pow.pass.cpp   | 7 +++----
 test/std/numerics/complex.number/cmplx.over/proj.pass.cpp  | 7 +++----
 test/std/numerics/complex.number/cmplx.over/real.pass.cpp  | 7 +++----
 .../complex.number/complex.literals/literals.pass.cpp      | 7 +++----
 .../complex.number/complex.literals/literals1.fail.cpp     | 7 +++----
 .../complex.number/complex.literals/literals1.pass.cpp     | 7 +++----
 .../complex.number/complex.literals/literals2.pass.cpp     | 7 +++----
 .../complex.member.ops/assignment_complex.pass.cpp         | 7 +++----
 .../complex.member.ops/assignment_scalar.pass.cpp          | 7 +++----
 .../complex.member.ops/divide_equal_complex.pass.cpp       | 7 +++----
 .../complex.member.ops/divide_equal_scalar.pass.cpp        | 7 +++----
 .../complex.member.ops/minus_equal_complex.pass.cpp        | 7 +++----
 .../complex.member.ops/minus_equal_scalar.pass.cpp         | 7 +++----
 .../complex.member.ops/plus_equal_complex.pass.cpp         | 7 +++----
 .../complex.member.ops/plus_equal_scalar.pass.cpp          | 7 +++----
 .../complex.member.ops/times_equal_complex.pass.cpp        | 7 +++----
 .../complex.member.ops/times_equal_scalar.pass.cpp         | 7 +++----
 .../complex.number/complex.members/construct.pass.cpp      | 7 +++----
 .../complex.number/complex.members/real_imag.pass.cpp      | 7 +++----
 .../complex.ops/complex_divide_complex.pass.cpp            | 7 +++----
 .../complex.ops/complex_divide_scalar.pass.cpp             | 7 +++----
 .../complex.ops/complex_equals_complex.pass.cpp            | 7 +++----
 .../complex.ops/complex_equals_scalar.pass.cpp             | 7 +++----
 .../complex.ops/complex_minus_complex.pass.cpp             | 7 +++----
 .../complex.ops/complex_minus_scalar.pass.cpp              | 7 +++----
 .../complex.ops/complex_not_equals_complex.pass.cpp        | 7 +++----
 .../complex.ops/complex_not_equals_scalar.pass.cpp         | 7 +++----
 .../complex.ops/complex_plus_complex.pass.cpp              | 7 +++----
 .../complex.ops/complex_plus_scalar.pass.cpp               | 7 +++----
 .../complex.ops/complex_times_complex.pass.cpp             | 7 +++----
 .../complex.ops/complex_times_scalar.pass.cpp              | 7 +++----
 .../complex.ops/scalar_divide_complex.pass.cpp             | 7 +++----
 .../complex.ops/scalar_equals_complex.pass.cpp             | 7 +++----
 .../complex.ops/scalar_minus_complex.pass.cpp              | 7 +++----
 .../complex.ops/scalar_not_equals_complex.pass.cpp         | 7 +++----
 .../complex.ops/scalar_plus_complex.pass.cpp               | 7 +++----
 .../complex.ops/scalar_times_complex.pass.cpp              | 7 +++----
 .../complex.number/complex.ops/stream_input.pass.cpp       | 7 +++----
 .../complex.number/complex.ops/stream_output.pass.cpp      | 7 +++----
 .../complex.number/complex.ops/unary_minus.pass.cpp        | 7 +++----
 .../complex.number/complex.ops/unary_plus.pass.cpp         | 7 +++----
 .../complex.special/double_float_explicit.pass.cpp         | 7 +++----
 .../complex.special/double_float_implicit.pass.cpp         | 7 +++----
 .../complex.special/double_long_double_explicit.pass.cpp   | 7 +++----
 .../complex.special/double_long_double_implicit.fail.cpp   | 7 +++----
 .../complex.special/float_double_explicit.pass.cpp         | 7 +++----
 .../complex.special/float_double_implicit.fail.cpp         | 7 +++----
 .../complex.special/float_long_double_explicit.pass.cpp    | 7 +++----
 .../complex.special/float_long_double_implicit.fail.cpp    | 7 +++----
 .../complex.special/long_double_double_explicit.pass.cpp   | 7 +++----
 .../complex.special/long_double_double_implicit.pass.cpp   | 7 +++----
 .../complex.special/long_double_float_explicit.pass.cpp    | 7 +++----
 .../complex.special/long_double_float_implicit.pass.cpp    | 7 +++----
 .../complex.number/complex.synopsis/nothing_to_do.pass.cpp | 7 +++----
 .../complex.number/complex.transcendentals/acos.pass.cpp   | 7 +++----
 .../complex.number/complex.transcendentals/acosh.pass.cpp  | 7 +++----
 .../complex.number/complex.transcendentals/asin.pass.cpp   | 7 +++----
 .../complex.number/complex.transcendentals/asinh.pass.cpp  | 7 +++----
 .../complex.number/complex.transcendentals/atan.pass.cpp   | 7 +++----
 .../complex.number/complex.transcendentals/atanh.pass.cpp  | 7 +++----
 .../complex.number/complex.transcendentals/cos.pass.cpp    | 7 +++----
 .../complex.number/complex.transcendentals/cosh.pass.cpp   | 7 +++----
 .../complex.number/complex.transcendentals/exp.pass.cpp    | 7 +++----
 .../complex.number/complex.transcendentals/log.pass.cpp    | 7 +++----
 .../complex.number/complex.transcendentals/log10.pass.cpp  | 7 +++----
 .../complex.transcendentals/pow_complex_complex.pass.cpp   | 7 +++----
 .../complex.transcendentals/pow_complex_scalar.pass.cpp    | 7 +++----
 .../complex.transcendentals/pow_scalar_complex.pass.cpp    | 7 +++----
 .../complex.number/complex.transcendentals/sin.pass.cpp    | 7 +++----
 .../complex.number/complex.transcendentals/sinh.pass.cpp   | 7 +++----
 .../complex.number/complex.transcendentals/sqrt.pass.cpp   | 7 +++----
 .../complex.number/complex.transcendentals/tan.pass.cpp    | 7 +++----
 .../complex.number/complex.transcendentals/tanh.pass.cpp   | 7 +++----
 .../numerics/complex.number/complex.value.ops/abs.pass.cpp | 7 +++----
 .../numerics/complex.number/complex.value.ops/arg.pass.cpp | 7 +++----
 .../complex.number/complex.value.ops/conj.pass.cpp         | 7 +++----
 .../complex.number/complex.value.ops/imag.pass.cpp         | 7 +++----
 .../complex.number/complex.value.ops/norm.pass.cpp         | 7 +++----
 .../complex.number/complex.value.ops/polar.pass.cpp        | 7 +++----
 .../complex.number/complex.value.ops/proj.pass.cpp         | 7 +++----
 .../complex.number/complex.value.ops/real.pass.cpp         | 7 +++----
 test/std/numerics/complex.number/complex/types.pass.cpp    | 7 +++----
 test/std/numerics/complex.number/layout.pass.cpp           | 7 +++----
 test/std/numerics/nothing_to_do.pass.cpp                   | 7 +++----
 .../class.gslice/gslice.access/tested_elsewhere.pass.cpp   | 7 +++----
 .../numarray/class.gslice/gslice.cons/default.pass.cpp     | 7 +++----
 .../class.gslice/gslice.cons/start_size_stride.pass.cpp    | 7 +++----
 .../numerics/numarray/class.gslice/nothing_to_do.pass.cpp  | 7 +++----
 .../numarray/class.slice/cons.slice/default.pass.cpp       | 7 +++----
 .../class.slice/cons.slice/start_size_stride.pass.cpp      | 7 +++----
 .../numerics/numarray/class.slice/nothing_to_do.pass.cpp   | 7 +++----
 .../class.slice/slice.access/tested_elsewhere.pass.cpp     | 7 +++----
 .../numarray/template.gslice.array/default.fail.cpp        | 7 +++----
 .../gslice.array.assign/gslice_array.pass.cpp              | 7 +++----
 .../gslice.array.assign/valarray.pass.cpp                  | 7 +++----
 .../gslice.array.comp.assign/addition.pass.cpp             | 7 +++----
 .../gslice.array.comp.assign/and.pass.cpp                  | 7 +++----
 .../gslice.array.comp.assign/divide.pass.cpp               | 7 +++----
 .../gslice.array.comp.assign/modulo.pass.cpp               | 7 +++----
 .../gslice.array.comp.assign/multiply.pass.cpp             | 7 +++----
 .../gslice.array.comp.assign/or.pass.cpp                   | 7 +++----
 .../gslice.array.comp.assign/shift_left.pass.cpp           | 7 +++----
 .../gslice.array.comp.assign/shift_right.pass.cpp          | 7 +++----
 .../gslice.array.comp.assign/subtraction.pass.cpp          | 7 +++----
 .../gslice.array.comp.assign/xor.pass.cpp                  | 7 +++----
 .../gslice.array.fill/assign_value.pass.cpp                | 7 +++----
 .../numerics/numarray/template.gslice.array/types.pass.cpp | 7 +++----
 .../numarray/template.indirect.array/default.fail.cpp      | 7 +++----
 .../indirect.array.assign/indirect_array.pass.cpp          | 7 +++----
 .../indirect.array.assign/valarray.pass.cpp                | 7 +++----
 .../indirect.array.comp.assign/addition.pass.cpp           | 7 +++----
 .../indirect.array.comp.assign/and.pass.cpp                | 7 +++----
 .../indirect.array.comp.assign/divide.pass.cpp             | 7 +++----
 .../indirect.array.comp.assign/modulo.pass.cpp             | 7 +++----
 .../indirect.array.comp.assign/multiply.pass.cpp           | 7 +++----
 .../indirect.array.comp.assign/or.pass.cpp                 | 7 +++----
 .../indirect.array.comp.assign/shift_left.pass.cpp         | 7 +++----
 .../indirect.array.comp.assign/shift_right.pass.cpp        | 7 +++----
 .../indirect.array.comp.assign/subtraction.pass.cpp        | 7 +++----
 .../indirect.array.comp.assign/xor.pass.cpp                | 7 +++----
 .../indirect.array.fill/assign_value.pass.cpp              | 7 +++----
 .../numarray/template.indirect.array/types.pass.cpp        | 7 +++----
 .../numerics/numarray/template.mask.array/default.fail.cpp | 7 +++----
 .../mask.array.assign/mask_array.pass.cpp                  | 7 +++----
 .../mask.array.assign/valarray.pass.cpp                    | 7 +++----
 .../mask.array.comp.assign/addition.pass.cpp               | 7 +++----
 .../mask.array.comp.assign/and.pass.cpp                    | 7 +++----
 .../mask.array.comp.assign/divide.pass.cpp                 | 7 +++----
 .../mask.array.comp.assign/modulo.pass.cpp                 | 7 +++----
 .../mask.array.comp.assign/multiply.pass.cpp               | 7 +++----
 .../template.mask.array/mask.array.comp.assign/or.pass.cpp | 7 +++----
 .../mask.array.comp.assign/shift_left.pass.cpp             | 7 +++----
 .../mask.array.comp.assign/shift_right.pass.cpp            | 7 +++----
 .../mask.array.comp.assign/subtraction.pass.cpp            | 7 +++----
 .../mask.array.comp.assign/xor.pass.cpp                    | 7 +++----
 .../mask.array.fill/assign_value.pass.cpp                  | 7 +++----
 .../numerics/numarray/template.mask.array/types.pass.cpp   | 7 +++----
 .../numarray/template.slice.array/default.fail.cpp         | 7 +++----
 .../slice.arr.assign/slice_array.pass.cpp                  | 7 +++----
 .../slice.arr.assign/valarray.pass.cpp                     | 7 +++----
 .../slice.arr.comp.assign/addition.pass.cpp                | 7 +++----
 .../slice.arr.comp.assign/and.pass.cpp                     | 7 +++----
 .../slice.arr.comp.assign/divide.pass.cpp                  | 7 +++----
 .../slice.arr.comp.assign/modulo.pass.cpp                  | 7 +++----
 .../slice.arr.comp.assign/multiply.pass.cpp                | 7 +++----
 .../template.slice.array/slice.arr.comp.assign/or.pass.cpp | 7 +++----
 .../slice.arr.comp.assign/shift_left.pass.cpp              | 7 +++----
 .../slice.arr.comp.assign/shift_right.pass.cpp             | 7 +++----
 .../slice.arr.comp.assign/subtraction.pass.cpp             | 7 +++----
 .../slice.arr.comp.assign/xor.pass.cpp                     | 7 +++----
 .../slice.arr.fill/assign_value.pass.cpp                   | 7 +++----
 .../numerics/numarray/template.slice.array/types.pass.cpp  | 7 +++----
 .../std/numerics/numarray/template.valarray/types.pass.cpp | 7 +++----
 .../template.valarray/valarray.access/access.pass.cpp      | 7 +++----
 .../valarray.access/const_access.pass.cpp                  | 7 +++----
 .../template.valarray/valarray.assign/copy_assign.pass.cpp | 7 +++----
 .../valarray.assign/gslice_array_assign.pass.cpp           | 7 +++----
 .../valarray.assign/indirect_array_assign.pass.cpp         | 7 +++----
 .../valarray.assign/initializer_list_assign.pass.cpp       | 7 +++----
 .../valarray.assign/mask_array_assign.pass.cpp             | 7 +++----
 .../template.valarray/valarray.assign/move_assign.pass.cpp | 7 +++----
 .../valarray.assign/slice_array_assign.pass.cpp            | 7 +++----
 .../valarray.assign/value_assign.pass.cpp                  | 7 +++----
 .../valarray.cassign/and_valarray.pass.cpp                 | 7 +++----
 .../template.valarray/valarray.cassign/and_value.pass.cpp  | 7 +++----
 .../valarray.cassign/divide_valarray.pass.cpp              | 7 +++----
 .../valarray.cassign/divide_value.pass.cpp                 | 7 +++----
 .../valarray.cassign/minus_valarray.pass.cpp               | 7 +++----
 .../valarray.cassign/minus_value.pass.cpp                  | 7 +++----
 .../valarray.cassign/modulo_valarray.pass.cpp              | 7 +++----
 .../valarray.cassign/modulo_value.pass.cpp                 | 7 +++----
 .../valarray.cassign/or_valarray.pass.cpp                  | 7 +++----
 .../template.valarray/valarray.cassign/or_value.pass.cpp   | 7 +++----
 .../valarray.cassign/plus_valarray.pass.cpp                | 7 +++----
 .../template.valarray/valarray.cassign/plus_value.pass.cpp | 7 +++----
 .../valarray.cassign/shift_left_valarray.pass.cpp          | 7 +++----
 .../valarray.cassign/shift_left_value.pass.cpp             | 7 +++----
 .../valarray.cassign/shift_right_valarray.pass.cpp         | 7 +++----
 .../valarray.cassign/shift_right_value.pass.cpp            | 7 +++----
 .../valarray.cassign/times_valarray.pass.cpp               | 7 +++----
 .../valarray.cassign/times_value.pass.cpp                  | 7 +++----
 .../valarray.cassign/xor_valarray.pass.cpp                 | 7 +++----
 .../template.valarray/valarray.cassign/xor_value.pass.cpp  | 7 +++----
 .../numarray/template.valarray/valarray.cons/copy.pass.cpp | 7 +++----
 .../template.valarray/valarray.cons/default.pass.cpp       | 7 +++----
 .../template.valarray/valarray.cons/gslice_array.pass.cpp  | 7 +++----
 .../valarray.cons/indirect_array.pass.cpp                  | 7 +++----
 .../valarray.cons/initializer_list.pass.cpp                | 7 +++----
 .../template.valarray/valarray.cons/mask_array.pass.cpp    | 7 +++----
 .../numarray/template.valarray/valarray.cons/move.pass.cpp | 7 +++----
 .../template.valarray/valarray.cons/pointer_size.pass.cpp  | 7 +++----
 .../numarray/template.valarray/valarray.cons/size.pass.cpp | 7 +++----
 .../template.valarray/valarray.cons/slice_array.pass.cpp   | 7 +++----
 .../template.valarray/valarray.cons/value_size.pass.cpp    | 7 +++----
 .../template.valarray/valarray.members/apply_cref.pass.cpp | 7 +++----
 .../valarray.members/apply_value.pass.cpp                  | 7 +++----
 .../template.valarray/valarray.members/cshift.pass.cpp     | 7 +++----
 .../template.valarray/valarray.members/max.pass.cpp        | 7 +++----
 .../template.valarray/valarray.members/min.pass.cpp        | 7 +++----
 .../template.valarray/valarray.members/resize.pass.cpp     | 7 +++----
 .../template.valarray/valarray.members/shift.pass.cpp      | 7 +++----
 .../template.valarray/valarray.members/size.pass.cpp       | 7 +++----
 .../template.valarray/valarray.members/sum.pass.cpp        | 7 +++----
 .../template.valarray/valarray.members/swap.pass.cpp       | 7 +++----
 .../template.valarray/valarray.sub/gslice_const.pass.cpp   | 7 +++----
 .../valarray.sub/gslice_non_const.pass.cpp                 | 7 +++----
 .../valarray.sub/indirect_array_const.pass.cpp             | 7 +++----
 .../valarray.sub/indirect_array_non_const.pass.cpp         | 7 +++----
 .../template.valarray/valarray.sub/slice_const.pass.cpp    | 7 +++----
 .../valarray.sub/slice_non_const.pass.cpp                  | 7 +++----
 .../valarray.sub/valarray_bool_const.pass.cpp              | 7 +++----
 .../valarray.sub/valarray_bool_non_const.pass.cpp          | 7 +++----
 .../template.valarray/valarray.unary/bit_not.pass.cpp      | 7 +++----
 .../template.valarray/valarray.unary/negate.pass.cpp       | 7 +++----
 .../numarray/template.valarray/valarray.unary/not.pass.cpp | 7 +++----
 .../template.valarray/valarray.unary/plus.pass.cpp         | 7 +++----
 .../numarray/valarray.nonmembers/nothing_to_do.pass.cpp    | 7 +++----
 .../valarray.binary/and_valarray_valarray.pass.cpp         | 7 +++----
 .../valarray.binary/and_valarray_value.pass.cpp            | 7 +++----
 .../valarray.binary/and_value_valarray.pass.cpp            | 7 +++----
 .../valarray.binary/divide_valarray_valarray.pass.cpp      | 7 +++----
 .../valarray.binary/divide_valarray_value.pass.cpp         | 7 +++----
 .../valarray.binary/divide_value_valarray.pass.cpp         | 7 +++----
 .../valarray.binary/minus_valarray_valarray.pass.cpp       | 7 +++----
 .../valarray.binary/minus_valarray_value.pass.cpp          | 7 +++----
 .../valarray.binary/minus_value_valarray.pass.cpp          | 7 +++----
 .../valarray.binary/modulo_valarray_valarray.pass.cpp      | 7 +++----
 .../valarray.binary/modulo_valarray_value.pass.cpp         | 7 +++----
 .../valarray.binary/modulo_value_valarray.pass.cpp         | 7 +++----
 .../valarray.binary/or_valarray_valarray.pass.cpp          | 7 +++----
 .../valarray.binary/or_valarray_value.pass.cpp             | 7 +++----
 .../valarray.binary/or_value_valarray.pass.cpp             | 7 +++----
 .../valarray.binary/plus_valarray_valarray.pass.cpp        | 7 +++----
 .../valarray.binary/plus_valarray_value.pass.cpp           | 7 +++----
 .../valarray.binary/plus_value_valarray.pass.cpp           | 7 +++----
 .../valarray.binary/shift_left_valarray_valarray.pass.cpp  | 7 +++----
 .../valarray.binary/shift_left_valarray_value.pass.cpp     | 7 +++----
 .../valarray.binary/shift_left_value_valarray.pass.cpp     | 7 +++----
 .../valarray.binary/shift_right_valarray_valarray.pass.cpp | 7 +++----
 .../valarray.binary/shift_right_valarray_value.pass.cpp    | 7 +++----
 .../valarray.binary/shift_right_value_valarray.pass.cpp    | 7 +++----
 .../valarray.binary/times_valarray_valarray.pass.cpp       | 7 +++----
 .../valarray.binary/times_valarray_value.pass.cpp          | 7 +++----
 .../valarray.binary/times_value_valarray.pass.cpp          | 7 +++----
 .../valarray.binary/xor_valarray_valarray.pass.cpp         | 7 +++----
 .../valarray.binary/xor_valarray_value.pass.cpp            | 7 +++----
 .../valarray.binary/xor_value_valarray.pass.cpp            | 7 +++----
 .../valarray.comparison/and_valarray_valarray.pass.cpp     | 7 +++----
 .../valarray.comparison/and_valarray_value.pass.cpp        | 7 +++----
 .../valarray.comparison/and_value_valarray.pass.cpp        | 7 +++----
 .../valarray.comparison/equal_valarray_valarray.pass.cpp   | 7 +++----
 .../valarray.comparison/equal_valarray_value.pass.cpp      | 7 +++----
 .../valarray.comparison/equal_value_valarray.pass.cpp      | 7 +++----
 .../greater_equal_valarray_valarray.pass.cpp               | 7 +++----
 .../greater_equal_valarray_value.pass.cpp                  | 7 +++----
 .../greater_equal_value_valarray.pass.cpp                  | 7 +++----
 .../valarray.comparison/greater_valarray_valarray.pass.cpp | 7 +++----
 .../valarray.comparison/greater_valarray_value.pass.cpp    | 7 +++----
 .../valarray.comparison/greater_value_valarray.pass.cpp    | 7 +++----
 .../less_equal_valarray_valarray.pass.cpp                  | 7 +++----
 .../valarray.comparison/less_equal_valarray_value.pass.cpp | 7 +++----
 .../valarray.comparison/less_equal_value_valarray.pass.cpp | 7 +++----
 .../valarray.comparison/less_valarray_valarray.pass.cpp    | 7 +++----
 .../valarray.comparison/less_valarray_value.pass.cpp       | 7 +++----
 .../valarray.comparison/less_value_valarray.pass.cpp       | 7 +++----
 .../not_equal_valarray_valarray.pass.cpp                   | 7 +++----
 .../valarray.comparison/not_equal_valarray_value.pass.cpp  | 7 +++----
 .../valarray.comparison/not_equal_value_valarray.pass.cpp  | 7 +++----
 .../valarray.comparison/or_valarray_valarray.pass.cpp      | 7 +++----
 .../valarray.comparison/or_valarray_value.pass.cpp         | 7 +++----
 .../valarray.comparison/or_value_valarray.pass.cpp         | 7 +++----
 .../valarray.nonmembers/valarray.special/swap.pass.cpp     | 7 +++----
 .../valarray.transcend/abs_valarray.pass.cpp               | 7 +++----
 .../valarray.transcend/acos_valarray.pass.cpp              | 7 +++----
 .../valarray.transcend/asin_valarray.pass.cpp              | 7 +++----
 .../valarray.transcend/atan2_valarray_valarray.pass.cpp    | 7 +++----
 .../valarray.transcend/atan2_valarray_value.pass.cpp       | 7 +++----
 .../valarray.transcend/atan2_value_valarray.pass.cpp       | 7 +++----
 .../valarray.transcend/atan_valarray.pass.cpp              | 7 +++----
 .../valarray.transcend/cos_valarray.pass.cpp               | 7 +++----
 .../valarray.transcend/cosh_valarray.pass.cpp              | 7 +++----
 .../valarray.transcend/exp_valarray.pass.cpp               | 7 +++----
 .../valarray.transcend/log10_valarray.pass.cpp             | 7 +++----
 .../valarray.transcend/log_valarray.pass.cpp               | 7 +++----
 .../valarray.transcend/pow_valarray_valarray.pass.cpp      | 7 +++----
 .../valarray.transcend/pow_valarray_value.pass.cpp         | 7 +++----
 .../valarray.transcend/pow_value_valarray.pass.cpp         | 7 +++----
 .../valarray.transcend/sin_valarray.pass.cpp               | 7 +++----
 .../valarray.transcend/sinh_valarray.pass.cpp              | 7 +++----
 .../valarray.transcend/sqrt_valarray.pass.cpp              | 7 +++----
 .../valarray.transcend/tan_valarray.pass.cpp               | 7 +++----
 .../valarray.transcend/tanh_valarray.pass.cpp              | 7 +++----
 .../numerics/numarray/valarray.range/begin_const.pass.cpp  | 7 +++----
 .../numarray/valarray.range/begin_non_const.pass.cpp       | 7 +++----
 .../numerics/numarray/valarray.range/end_const.pass.cpp    | 7 +++----
 .../numarray/valarray.range/end_non_const.pass.cpp         | 7 +++----
 .../numerics/numarray/valarray.syn/nothing_to_do.pass.cpp  | 7 +++----
 .../numerics/numeric.ops/accumulate/accumulate.pass.cpp    | 7 +++----
 .../numerics/numeric.ops/accumulate/accumulate_op.pass.cpp | 7 +++----
 .../adjacent.difference/adjacent_difference.pass.cpp       | 7 +++----
 .../adjacent.difference/adjacent_difference_op.pass.cpp    | 7 +++----
 .../numeric.ops/exclusive.scan/exclusive_scan.pass.cpp     | 7 +++----
 .../exclusive.scan/exclusive_scan_init_op.pass.cpp         | 7 +++----
 .../numeric.ops/inclusive.scan/inclusive_scan.pass.cpp     | 7 +++----
 .../numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp  | 7 +++----
 .../inclusive.scan/inclusive_scan_op_init.pass.cpp         | 7 +++----
 .../numeric.ops/inner.product/inner_product.pass.cpp       | 7 +++----
 .../numeric.ops/inner.product/inner_product_comp.pass.cpp  | 7 +++----
 test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp   | 7 +++----
 .../numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp | 7 +++----
 .../numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp | 7 +++----
 test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp | 7 +++----
 .../numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp         | 7 +++----
 .../numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp | 7 +++----
 .../numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp | 7 +++----
 test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp | 7 +++----
 .../numerics/numeric.ops/partial.sum/partial_sum.pass.cpp  | 7 +++----
 .../numeric.ops/partial.sum/partial_sum_op.pass.cpp        | 7 +++----
 test/std/numerics/numeric.ops/reduce/reduce.pass.cpp       | 7 +++----
 test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp  | 7 +++----
 .../numerics/numeric.ops/reduce/reduce_init_op.pass.cpp    | 7 +++----
 .../transform_exclusive_scan_init_bop_uop.pass.cpp         | 7 +++----
 .../transform_inclusive_scan_bop_uop.pass.cpp              | 7 +++----
 .../transform_inclusive_scan_bop_uop_init.pass.cpp         | 7 +++----
 .../transform_reduce_iter_iter_init_bop_uop.pass.cpp       | 7 +++----
 .../transform_reduce_iter_iter_iter_init.pass.cpp          | 7 +++----
 .../transform_reduce_iter_iter_iter_init_op_op.pass.cpp    | 7 +++----
 .../numerics/numeric.requirements/nothing_to_do.pass.cpp   | 7 +++----
 test/std/numerics/numerics.general/nothing_to_do.pass.cpp  | 7 +++----
 test/std/numerics/rand/nothing_to_do.pass.cpp              | 7 +++----
 test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp   | 7 +++----
 .../rand/rand.adapt/rand.adapt.disc/assign.pass.cpp        | 7 +++----
 .../numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp | 7 +++----
 .../rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp   | 7 +++----
 .../rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp   | 7 +++----
 .../rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp   | 7 +++----
 .../rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp     | 7 +++----
 .../rand/rand.adapt/rand.adapt.disc/default.pass.cpp       | 7 +++----
 .../rand/rand.adapt/rand.adapt.disc/discard.pass.cpp       | 7 +++----
 .../numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp | 7 +++----
 .../numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp   | 7 +++----
 .../rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp   | 7 +++----
 .../rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp   | 7 +++----
 .../rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp     | 7 +++----
 .../rand/rand.adapt/rand.adapt.disc/values.pass.cpp        | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp       | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp         | 7 +++----
 .../rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp  | 7 +++----
 .../rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp  | 7 +++----
 .../rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp  | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp    | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/default.pass.cpp      | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp      | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp         | 7 +++----
 .../numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp  | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp  | 7 +++----
 .../rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp  | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp    | 7 +++----
 .../rand/rand.adapt/rand.adapt.ibits/values.pass.cpp       | 7 +++----
 .../rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp        | 7 +++----
 .../numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp | 7 +++----
 .../rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp   | 7 +++----
 .../rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp   | 7 +++----
 .../rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp   | 7 +++----
 .../rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp     | 7 +++----
 .../rand/rand.adapt/rand.adapt.shuf/default.pass.cpp       | 7 +++----
 .../rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp       | 7 +++----
 .../numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp | 7 +++----
 .../numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp   | 7 +++----
 .../rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp   | 7 +++----
 .../rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp   | 7 +++----
 .../rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp     | 7 +++----
 .../rand/rand.adapt/rand.adapt.shuf/values.pass.cpp        | 7 +++----
 test/std/numerics/rand/rand.device/ctor.pass.cpp           | 7 +++----
 test/std/numerics/rand/rand.device/entropy.pass.cpp        | 7 +++----
 test/std/numerics/rand/rand.device/eval.pass.cpp           | 7 +++----
 test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp     | 7 +++----
 .../rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp    | 7 +++----
 .../rand.dist.bern.bernoulli/assign.pass.cpp               | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp  | 7 +++----
 .../rand.dist.bern.bernoulli/ctor_double.pass.cpp          | 7 +++----
 .../rand.dist.bern.bernoulli/ctor_param.pass.cpp           | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp    | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp  | 7 +++----
 .../rand.dist.bern.bernoulli/eval_param.pass.cpp           | 7 +++----
 .../rand.dist.bern.bernoulli/get_param.pass.cpp            | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp    | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp   | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp   | 7 +++----
 .../rand.dist.bern.bernoulli/param_assign.pass.cpp         | 7 +++----
 .../rand.dist.bern.bernoulli/param_copy.pass.cpp           | 7 +++----
 .../rand.dist.bern.bernoulli/param_ctor.pass.cpp           | 7 +++----
 .../rand.dist.bern.bernoulli/param_eq.pass.cpp             | 7 +++----
 .../rand.dist.bern.bernoulli/param_types.pass.cpp          | 7 +++----
 .../rand.dist.bern.bernoulli/set_param.pass.cpp            | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp      | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp        | 7 +++----
 .../rand.dist.bern.bin/ctor_int_double.pass.cpp            | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp  | 7 +++----
 .../rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp        | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp  | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/max.pass.cpp         | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/min.pass.cpp         | 7 +++----
 .../rand.dist.bern.bin/param_assign.pass.cpp               | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp  | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp  | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp    | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp   | 7 +++----
 .../rand.dist.bern/rand.dist.bern.bin/types.pass.cpp       | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp      | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp        | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp  | 7 +++----
 .../rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp        | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp  | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/max.pass.cpp         | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/min.pass.cpp         | 7 +++----
 .../rand.dist.bern.geo/param_assign.pass.cpp               | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp  | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp  | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp    | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp   | 7 +++----
 .../rand.dist.bern/rand.dist.bern.geo/types.pass.cpp       | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp   | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp     | 7 +++----
 .../rand.dist.bern.negbin/ctor_int_double.pass.cpp         | 7 +++----
 .../rand.dist.bern.negbin/ctor_param.pass.cpp              | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp       | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp     | 7 +++----
 .../rand.dist.bern.negbin/eval_param.pass.cpp              | 7 +++----
 .../rand.dist.bern.negbin/get_param.pass.cpp               | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp       | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp      | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp      | 7 +++----
 .../rand.dist.bern.negbin/param_assign.pass.cpp            | 7 +++----
 .../rand.dist.bern.negbin/param_copy.pass.cpp              | 7 +++----
 .../rand.dist.bern.negbin/param_ctor.pass.cpp              | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp | 7 +++----
 .../rand.dist.bern.negbin/param_types.pass.cpp             | 7 +++----
 .../rand.dist.bern.negbin/set_param.pass.cpp               | 7 +++----
 .../rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp    | 7 +++----
 .../rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp   | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp     | 7 +++----
 .../rand.dist.norm.cauchy/ctor_double_double.pass.cpp      | 7 +++----
 .../rand.dist.norm.cauchy/ctor_param.pass.cpp              | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp       | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp     | 7 +++----
 .../rand.dist.norm.cauchy/eval_param.pass.cpp              | 7 +++----
 .../rand.dist.norm.cauchy/get_param.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp       | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp      | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp      | 7 +++----
 .../rand.dist.norm.cauchy/param_assign.pass.cpp            | 7 +++----
 .../rand.dist.norm.cauchy/param_copy.pass.cpp              | 7 +++----
 .../rand.dist.norm.cauchy/param_ctor.pass.cpp              | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp | 7 +++----
 .../rand.dist.norm.cauchy/param_types.pass.cpp             | 7 +++----
 .../rand.dist.norm.cauchy/set_param.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp      | 7 +++----
 .../rand.dist.norm.chisq/ctor_double.pass.cpp              | 7 +++----
 .../rand.dist.norm.chisq/ctor_param.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp        | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp      | 7 +++----
 .../rand.dist.norm.chisq/eval_param.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp        | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp       | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp       | 7 +++----
 .../rand.dist.norm.chisq/param_assign.pass.cpp             | 7 +++----
 .../rand.dist.norm.chisq/param_copy.pass.cpp               | 7 +++----
 .../rand.dist.norm.chisq/param_ctor.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp  | 7 +++----
 .../rand.dist.norm.chisq/param_types.pass.cpp              | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp | 7 +++----
 .../rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp     | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/assign.pass.cpp        | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp | 7 +++----
 .../rand.dist.norm.f/ctor_double_double.pass.cpp           | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp    | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp     | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp  | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp  | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp  | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp      | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp   | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp     | 7 +++----
 .../rand.dist.norm/rand.dist.norm.f/types.pass.cpp         | 7 +++----
 .../rand.dist.norm.lognormal/assign.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp  | 7 +++----
 .../rand.dist.norm.lognormal/ctor_double_double.pass.cpp   | 7 +++----
 .../rand.dist.norm.lognormal/ctor_param.pass.cpp           | 7 +++----
 .../rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp  | 7 +++----
 .../rand.dist.norm.lognormal/eval_param.pass.cpp           | 7 +++----
 .../rand.dist.norm.lognormal/get_param.pass.cpp            | 7 +++----
 .../rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp   | 7 +++----
 .../rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp   | 7 +++----
 .../rand.dist.norm.lognormal/param_assign.pass.cpp         | 7 +++----
 .../rand.dist.norm.lognormal/param_copy.pass.cpp           | 7 +++----
 .../rand.dist.norm.lognormal/param_ctor.pass.cpp           | 7 +++----
 .../rand.dist.norm.lognormal/param_eq.pass.cpp             | 7 +++----
 .../rand.dist.norm.lognormal/param_types.pass.cpp          | 7 +++----
 .../rand.dist.norm.lognormal/set_param.pass.cpp            | 7 +++----
 .../rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp   | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp     | 7 +++----
 .../rand.dist.norm.normal/ctor_double_double.pass.cpp      | 7 +++----
 .../rand.dist.norm.normal/ctor_param.pass.cpp              | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp       | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp     | 7 +++----
 .../rand.dist.norm.normal/eval_param.pass.cpp              | 7 +++----
 .../rand.dist.norm.normal/get_param.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/io.pass.cpp       | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/max.pass.cpp      | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/min.pass.cpp      | 7 +++----
 .../rand.dist.norm.normal/param_assign.pass.cpp            | 7 +++----
 .../rand.dist.norm.normal/param_copy.pass.cpp              | 7 +++----
 .../rand.dist.norm.normal/param_ctor.pass.cpp              | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp | 7 +++----
 .../rand.dist.norm.normal/param_types.pass.cpp             | 7 +++----
 .../rand.dist.norm.normal/set_param.pass.cpp               | 7 +++----
 .../rand.dist.norm/rand.dist.norm.normal/types.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/assign.pass.cpp        | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp   | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp    | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp     | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp  | 7 +++----
 .../rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp  | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp  | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp    | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp      | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp   | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp     | 7 +++----
 .../rand.dist.norm/rand.dist.norm.t/types.pass.cpp         | 7 +++----
 .../rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp    | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp      | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp        | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp  | 7 +++----
 .../rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp        | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp  | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/max.pass.cpp         | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/min.pass.cpp         | 7 +++----
 .../rand.dist.pois.exp/param_assign.pass.cpp               | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp  | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp  | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp    | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp   | 7 +++----
 .../rand.dist.pois/rand.dist.pois.exp/types.pass.cpp       | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp  | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp    | 7 +++----
 .../rand.dist.pois.extreme/ctor_double_double.pass.cpp     | 7 +++----
 .../rand.dist.pois.extreme/ctor_param.pass.cpp             | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp      | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp    | 7 +++----
 .../rand.dist.pois.extreme/eval_param.pass.cpp             | 7 +++----
 .../rand.dist.pois.extreme/get_param.pass.cpp              | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp      | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp     | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp     | 7 +++----
 .../rand.dist.pois.extreme/param_assign.pass.cpp           | 7 +++----
 .../rand.dist.pois.extreme/param_copy.pass.cpp             | 7 +++----
 .../rand.dist.pois.extreme/param_ctor.pass.cpp             | 7 +++----
 .../rand.dist.pois.extreme/param_eq.pass.cpp               | 7 +++----
 .../rand.dist.pois.extreme/param_types.pass.cpp            | 7 +++----
 .../rand.dist.pois.extreme/set_param.pass.cpp              | 7 +++----
 .../rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp   | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp    | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp      | 7 +++----
 .../rand.dist.pois.gamma/ctor_double_double.pass.cpp       | 7 +++----
 .../rand.dist.pois.gamma/ctor_param.pass.cpp               | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp        | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp      | 7 +++----
 .../rand.dist.pois.gamma/eval_param.pass.cpp               | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp        | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp       | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp       | 7 +++----
 .../rand.dist.pois.gamma/param_assign.pass.cpp             | 7 +++----
 .../rand.dist.pois.gamma/param_copy.pass.cpp               | 7 +++----
 .../rand.dist.pois.gamma/param_ctor.pass.cpp               | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp  | 7 +++----
 .../rand.dist.pois.gamma/param_types.pass.cpp              | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp | 7 +++----
 .../rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp     | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp  | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp    | 7 +++----
 .../rand.dist.pois.poisson/ctor_double.pass.cpp            | 7 +++----
 .../rand.dist.pois.poisson/ctor_param.pass.cpp             | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp      | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp    | 7 +++----
 .../rand.dist.pois.poisson/eval_param.pass.cpp             | 7 +++----
 .../rand.dist.pois.poisson/get_param.pass.cpp              | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp      | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp     | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp     | 7 +++----
 .../rand.dist.pois.poisson/param_assign.pass.cpp           | 7 +++----
 .../rand.dist.pois.poisson/param_copy.pass.cpp             | 7 +++----
 .../rand.dist.pois.poisson/param_ctor.pass.cpp             | 7 +++----
 .../rand.dist.pois.poisson/param_eq.pass.cpp               | 7 +++----
 .../rand.dist.pois.poisson/param_types.pass.cpp            | 7 +++----
 .../rand.dist.pois.poisson/set_param.pass.cpp              | 7 +++----
 .../rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp   | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp  | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp    | 7 +++----
 .../rand.dist.pois.weibull/ctor_double_double.pass.cpp     | 7 +++----
 .../rand.dist.pois.weibull/ctor_param.pass.cpp             | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp      | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp    | 7 +++----
 .../rand.dist.pois.weibull/eval_param.pass.cpp             | 7 +++----
 .../rand.dist.pois.weibull/get_param.pass.cpp              | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp      | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp     | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp     | 7 +++----
 .../rand.dist.pois.weibull/param_assign.pass.cpp           | 7 +++----
 .../rand.dist.pois.weibull/param_copy.pass.cpp             | 7 +++----
 .../rand.dist.pois.weibull/param_ctor.pass.cpp             | 7 +++----
 .../rand.dist.pois.weibull/param_eq.pass.cpp               | 7 +++----
 .../rand.dist.pois.weibull/param_types.pass.cpp            | 7 +++----
 .../rand.dist.pois.weibull/set_param.pass.cpp              | 7 +++----
 .../rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp   | 7 +++----
 .../rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp    | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp   | 7 +++----
 .../rand.dist.samp.discrete/ctor_default.pass.cpp          | 7 +++----
 .../rand.dist.samp.discrete/ctor_func.pass.cpp             | 7 +++----
 .../rand.dist.samp.discrete/ctor_init.pass.cpp             | 7 +++----
 .../rand.dist.samp.discrete/ctor_iterator.pass.cpp         | 7 +++----
 .../rand.dist.samp.discrete/ctor_param.pass.cpp            | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp     | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp   | 7 +++----
 .../rand.dist.samp.discrete/eval_param.pass.cpp            | 7 +++----
 .../rand.dist.samp.discrete/get_param.pass.cpp             | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp     | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp    | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp    | 7 +++----
 .../rand.dist.samp.discrete/param_assign.pass.cpp          | 7 +++----
 .../rand.dist.samp.discrete/param_copy.pass.cpp            | 7 +++----
 .../rand.dist.samp.discrete/param_ctor_default.pass.cpp    | 7 +++----
 .../rand.dist.samp.discrete/param_ctor_func.pass.cpp       | 7 +++----
 .../rand.dist.samp.discrete/param_ctor_init.pass.cpp       | 7 +++----
 .../rand.dist.samp.discrete/param_ctor_iterator.pass.cpp   | 7 +++----
 .../rand.dist.samp.discrete/param_eq.pass.cpp              | 7 +++----
 .../rand.dist.samp.discrete/param_types.pass.cpp           | 7 +++----
 .../rand.dist.samp.discrete/set_param.pass.cpp             | 7 +++----
 .../rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp  | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp   | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp     | 7 +++----
 .../rand.dist.samp.pconst/ctor_default.pass.cpp            | 7 +++----
 .../rand.dist.samp.pconst/ctor_func.pass.cpp               | 7 +++----
 .../rand.dist.samp.pconst/ctor_init_func.pass.cpp          | 7 +++----
 .../rand.dist.samp.pconst/ctor_iterator.pass.cpp           | 7 +++----
 .../rand.dist.samp.pconst/ctor_param.pass.cpp              | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp       | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp     | 7 +++----
 .../rand.dist.samp.pconst/eval_param.pass.cpp              | 7 +++----
 .../rand.dist.samp.pconst/get_param.pass.cpp               | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp       | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp      | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp      | 7 +++----
 .../rand.dist.samp.pconst/param_assign.pass.cpp            | 7 +++----
 .../rand.dist.samp.pconst/param_copy.pass.cpp              | 7 +++----
 .../rand.dist.samp.pconst/param_ctor_default.pass.cpp      | 7 +++----
 .../rand.dist.samp.pconst/param_ctor_func.pass.cpp         | 7 +++----
 .../rand.dist.samp.pconst/param_ctor_init_func.pass.cpp    | 7 +++----
 .../rand.dist.samp.pconst/param_ctor_iterator.pass.cpp     | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp | 7 +++----
 .../rand.dist.samp.pconst/param_types.pass.cpp             | 7 +++----
 .../rand.dist.samp.pconst/set_param.pass.cpp               | 7 +++----
 .../rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp    | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp  | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp    | 7 +++----
 .../rand.dist.samp.plinear/ctor_default.pass.cpp           | 7 +++----
 .../rand.dist.samp.plinear/ctor_func.pass.cpp              | 7 +++----
 .../rand.dist.samp.plinear/ctor_init_func.pass.cpp         | 7 +++----
 .../rand.dist.samp.plinear/ctor_iterator.pass.cpp          | 7 +++----
 .../rand.dist.samp.plinear/ctor_param.pass.cpp             | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp      | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp    | 7 +++----
 .../rand.dist.samp.plinear/eval_param.pass.cpp             | 7 +++----
 .../rand.dist.samp.plinear/get_param.pass.cpp              | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp      | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp     | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp     | 7 +++----
 .../rand.dist.samp.plinear/param_assign.pass.cpp           | 7 +++----
 .../rand.dist.samp.plinear/param_copy.pass.cpp             | 7 +++----
 .../rand.dist.samp.plinear/param_ctor_default.pass.cpp     | 7 +++----
 .../rand.dist.samp.plinear/param_ctor_func.pass.cpp        | 7 +++----
 .../rand.dist.samp.plinear/param_ctor_init_func.pass.cpp   | 7 +++----
 .../rand.dist.samp.plinear/param_ctor_iterator.pass.cpp    | 7 +++----
 .../rand.dist.samp.plinear/param_eq.pass.cpp               | 7 +++----
 .../rand.dist.samp.plinear/param_types.pass.cpp            | 7 +++----
 .../rand.dist.samp.plinear/set_param.pass.cpp              | 7 +++----
 .../rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp   | 7 +++----
 .../rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp     | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/assign.pass.cpp        | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp  | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp    | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp    | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp     | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp  | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp  | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp  | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp    | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp    | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp      | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp   | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp     | 7 +++----
 .../rand.dist.uni/rand.dist.uni.int/types.pass.cpp         | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/assign.pass.cpp       | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/copy.pass.cpp         | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp   | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp  | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/eval.pass.cpp         | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp   | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp    | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp  | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp | 7 +++----
 .../rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp   | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp   | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp     | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp  | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp    | 7 +++----
 .../rand.dist.uni/rand.dist.uni.real/types.pass.cpp        | 7 +++----
 test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp     | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp  | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp    | 7 +++----
 .../rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp | 7 +++----
 .../rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp        | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp    | 7 +++----
 test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp | 7 +++----
 .../rand/rand.eng/rand.eng.lcong/result_type.pass.cpp      | 7 +++----
 .../rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp | 7 +++----
 .../rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp        | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp  | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp   | 7 +++----
 .../std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp | 7 +++----
 .../rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp  | 7 +++----
 .../rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp         | 7 +++----
 .../rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp     | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp  | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp  | 7 +++----
 .../std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp | 7 +++----
 test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp  | 7 +++----
 .../rand/rand.eng/rand.eng.mers/result_type.pass.cpp       | 7 +++----
 .../rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp  | 7 +++----
 .../rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp         | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp   | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp    | 7 +++----
 test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp | 7 +++----
 .../rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp   | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp   | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp   | 7 +++----
 test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp | 7 +++----
 test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp   | 7 +++----
 .../rand/rand.eng/rand.eng.sub/result_type.pass.cpp        | 7 +++----
 .../rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp   | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp | 7 +++----
 .../numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp    | 7 +++----
 .../rand/rand.predef/default_random_engine.pass.cpp        | 7 +++----
 test/std/numerics/rand/rand.predef/knuth_b.pass.cpp        | 7 +++----
 test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp    | 7 +++----
 test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp   | 7 +++----
 test/std/numerics/rand/rand.predef/mt19937.pass.cpp        | 7 +++----
 test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp     | 7 +++----
 test/std/numerics/rand/rand.predef/ranlux24.pass.cpp       | 7 +++----
 test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp  | 7 +++----
 test/std/numerics/rand/rand.predef/ranlux48.pass.cpp       | 7 +++----
 test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp  | 7 +++----
 test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp     | 7 +++----
 .../rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp    | 7 +++----
 .../rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp      | 7 +++----
 .../rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp      | 7 +++----
 .../rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp     | 7 +++----
 .../rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp  | 7 +++----
 .../rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp     | 7 +++----
 test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp    | 7 +++----
 .../rand.util.canonical/generate_canonical.pass.cpp        | 7 +++----
 .../rand/rand.util/rand.util.seedseq/assign.fail.cpp       | 7 +++----
 .../rand/rand.util/rand.util.seedseq/copy.fail.cpp         | 7 +++----
 .../rand/rand.util/rand.util.seedseq/default.pass.cpp      | 7 +++----
 .../rand/rand.util/rand.util.seedseq/generate.pass.cpp     | 7 +++----
 .../rand.util/rand.util.seedseq/initializer_list.pass.cpp  | 7 +++----
 .../rand/rand.util/rand.util.seedseq/iterator.pass.cpp     | 7 +++----
 .../rand/rand.util/rand.util.seedseq/types.pass.cpp        | 7 +++----
 test/std/re/nothing_to_do.pass.cpp                         | 7 +++----
 test/std/re/re.alg/nothing_to_do.pass.cpp                  | 7 +++----
 test/std/re/re.alg/re.alg.match/awk.pass.cpp               | 7 +++----
 test/std/re/re.alg/re.alg.match/basic.fail.cpp             | 7 +++----
 test/std/re/re.alg/re.alg.match/basic.pass.cpp             | 7 +++----
 test/std/re/re.alg/re.alg.match/ecma.pass.cpp              | 7 +++----
 test/std/re/re.alg/re.alg.match/egrep.pass.cpp             | 7 +++----
 test/std/re/re.alg/re.alg.match/exponential.pass.cpp       | 7 +++----
 test/std/re/re.alg/re.alg.match/extended.pass.cpp          | 7 +++----
 test/std/re/re.alg/re.alg.match/grep.pass.cpp              | 7 +++----
 .../re.alg.match/inverted_character_classes.pass.cpp       | 7 +++----
 test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp | 7 +++----
 .../re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp   | 7 +++----
 test/std/re/re.alg/re.alg.replace/test1.pass.cpp           | 7 +++----
 test/std/re/re.alg/re.alg.replace/test2.pass.cpp           | 7 +++----
 test/std/re/re.alg/re.alg.replace/test3.pass.cpp           | 7 +++----
 test/std/re/re.alg/re.alg.replace/test4.pass.cpp           | 7 +++----
 test/std/re/re.alg/re.alg.replace/test5.pass.cpp           | 7 +++----
 test/std/re/re.alg/re.alg.replace/test6.pass.cpp           | 7 +++----
 test/std/re/re.alg/re.alg.search/awk.pass.cpp              | 7 +++----
 test/std/re/re.alg/re.alg.search/backup.pass.cpp           | 7 +++----
 test/std/re/re.alg/re.alg.search/basic.fail.cpp            | 7 +++----
 test/std/re/re.alg/re.alg.search/basic.pass.cpp            | 7 +++----
 test/std/re/re.alg/re.alg.search/ecma.pass.cpp             | 7 +++----
 test/std/re/re.alg/re.alg.search/egrep.pass.cpp            | 7 +++----
 test/std/re/re.alg/re.alg.search/exponential.pass.cpp      | 7 +++----
 test/std/re/re.alg/re.alg.search/extended.pass.cpp         | 7 +++----
 test/std/re/re.alg/re.alg.search/grep.pass.cpp             | 7 +++----
 .../re.alg/re.alg.search/invert_neg_word_search.pass.cpp   | 7 +++----
 test/std/re/re.alg/re.alg.search/lookahead.pass.cpp        | 7 +++----
 test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp    | 7 +++----
 test/std/re/re.alg/re.except/nothing_to_do.pass.cpp        | 7 +++----
 test/std/re/re.badexp/regex_error.pass.cpp                 | 7 +++----
 test/std/re/re.const/nothing_to_do.pass.cpp                | 7 +++----
 test/std/re/re.const/re.err/error_type.pass.cpp            | 7 +++----
 test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp | 7 +++----
 test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp   | 7 +++----
 test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp   | 7 +++----
 test/std/re/re.const/re.matchflag/match_not_null.pass.cpp  | 7 +++----
 test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp | 7 +++----
 .../defns.regex.collating.element/nothing_to_do.pass.cpp   | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../defns.regex.format.specifier/nothing_to_do.pass.cpp    | 7 +++----
 .../re/re.def/defns.regex.matched/nothing_to_do.pass.cpp   | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../defns.regex.regular.expression/nothing_to_do.pass.cpp  | 7 +++----
 .../defns.regex.subexpression/nothing_to_do.pass.cpp       | 7 +++----
 test/std/re/re.def/nothing_to_do.pass.cpp                  | 7 +++----
 test/std/re/re.general/nothing_to_do.pass.cpp              | 7 +++----
 test/std/re/re.grammar/excessive_brace_count.pass.cpp      | 7 +++----
 test/std/re/re.grammar/nothing_to_do.pass.cpp              | 7 +++----
 test/std/re/re.iter/nothing_to_do.pass.cpp                 | 7 +++----
 .../re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp  | 7 +++----
 .../re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp  | 7 +++----
 .../re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp   | 7 +++----
 .../re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp   | 7 +++----
 .../re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp  | 7 +++----
 .../re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp    | 7 +++----
 test/std/re/re.iter/re.regiter/types.pass.cpp              | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp  | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp  | 7 +++----
 .../re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp   | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp   | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp   | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp    | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp    | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp   | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp  | 7 +++----
 .../re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp    | 7 +++----
 test/std/re/re.iter/re.tokiter/types.pass.cpp              | 7 +++----
 test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp    | 7 +++----
 test/std/re/re.regex/re.regex.assign/assign.pass.cpp       | 7 +++----
 .../re.regex.assign/assign_iter_iter_flag.pass.cpp         | 7 +++----
 .../re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp   | 7 +++----
 .../re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp | 7 +++----
 .../re.regex/re.regex.assign/assign_string_flag.pass.cpp   | 7 +++----
 test/std/re/re.regex/re.regex.assign/copy.pass.cpp         | 7 +++----
 test/std/re/re.regex/re.regex.assign/il.pass.cpp           | 7 +++----
 test/std/re/re.regex/re.regex.assign/ptr.pass.cpp          | 7 +++----
 test/std/re/re.regex/re.regex.assign/string.pass.cpp       | 7 +++----
 test/std/re/re.regex/re.regex.const/constants.pass.cpp     | 7 +++----
 test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp   | 7 +++----
 .../re/re.regex/re.regex.construct/bad_backref.pass.cpp    | 7 +++----
 test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp | 7 +++----
 .../std/re/re.regex/re.regex.construct/bad_escape.pass.cpp | 7 +++----
 .../std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp | 7 +++----
 test/std/re/re.regex/re.regex.construct/copy.pass.cpp      | 7 +++----
 test/std/re/re.regex/re.regex.construct/deduct.fail.cpp    | 7 +++----
 test/std/re/re.regex/re.regex.construct/deduct.pass.cpp    | 7 +++----
 test/std/re/re.regex/re.regex.construct/default.pass.cpp   | 7 +++----
 test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp    | 7 +++----
 test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp | 7 +++----
 .../re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp  | 7 +++----
 test/std/re/re.regex/re.regex.construct/ptr.pass.cpp       | 7 +++----
 test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp   | 7 +++----
 test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp  | 7 +++----
 .../re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp   | 7 +++----
 test/std/re/re.regex/re.regex.construct/string.pass.cpp    | 7 +++----
 .../std/re/re.regex/re.regex.construct/string_flg.pass.cpp | 7 +++----
 test/std/re/re.regex/re.regex.locale/imbue.pass.cpp        | 7 +++----
 .../re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp    | 7 +++----
 .../re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp         | 7 +++----
 .../re.regex/re.regex.operations/tested_elsewhere.pass.cpp | 7 +++----
 test/std/re/re.regex/re.regex.swap/swap.pass.cpp           | 7 +++----
 test/std/re/re.regex/types.pass.cpp                        | 7 +++----
 test/std/re/re.req/nothing_to_do.pass.cpp                  | 7 +++----
 test/std/re/re.results/re.results.acc/begin_end.pass.cpp   | 7 +++----
 test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp | 7 +++----
 test/std/re/re.results/re.results.acc/index.pass.cpp       | 7 +++----
 test/std/re/re.results/re.results.acc/length.pass.cpp      | 7 +++----
 test/std/re/re.results/re.results.acc/position.pass.cpp    | 7 +++----
 test/std/re/re.results/re.results.acc/prefix.pass.cpp      | 7 +++----
 test/std/re/re.results/re.results.acc/str.pass.cpp         | 7 +++----
 test/std/re/re.results/re.results.acc/suffix.pass.cpp      | 7 +++----
 .../re/re.results/re.results.all/get_allocator.pass.cpp    | 7 +++----
 test/std/re/re.results/re.results.const/allocator.pass.cpp | 7 +++----
 test/std/re/re.results/re.results.const/copy.pass.cpp      | 7 +++----
 .../re/re.results/re.results.const/copy_assign.pass.cpp    | 7 +++----
 test/std/re/re.results/re.results.const/default.pass.cpp   | 7 +++----
 test/std/re/re.results/re.results.const/move.pass.cpp      | 7 +++----
 .../re/re.results/re.results.const/move_assign.pass.cpp    | 7 +++----
 test/std/re/re.results/re.results.form/form1.pass.cpp      | 7 +++----
 test/std/re/re.results/re.results.form/form2.pass.cpp      | 7 +++----
 test/std/re/re.results/re.results.form/form3.pass.cpp      | 7 +++----
 test/std/re/re.results/re.results.form/form4.pass.cpp      | 7 +++----
 test/std/re/re.results/re.results.nonmember/equal.pass.cpp | 7 +++----
 test/std/re/re.results/re.results.size/empty.fail.cpp      | 7 +++----
 test/std/re/re.results/re.results.size/empty.pass.cpp      | 7 +++----
 test/std/re/re.results/re.results.size/max_size.pass.cpp   | 7 +++----
 test/std/re/re.results/re.results.state/ready.pass.cpp     | 7 +++----
 .../std/re/re.results/re.results.swap/member_swap.pass.cpp | 7 +++----
 .../re/re.results/re.results.swap/non_member_swap.pass.cpp | 7 +++----
 test/std/re/re.results/types.pass.cpp                      | 7 +++----
 .../re.submatch.members/compare_string_type.pass.cpp       | 7 +++----
 .../re.submatch.members/compare_sub_match.pass.cpp         | 7 +++----
 .../re.submatch.members/compare_value_type_ptr.pass.cpp    | 7 +++----
 .../re/re.submatch/re.submatch.members/default.pass.cpp    | 7 +++----
 .../std/re/re.submatch/re.submatch.members/length.pass.cpp | 7 +++----
 .../re.submatch.members/operator_string.pass.cpp           | 7 +++----
 test/std/re/re.submatch/re.submatch.members/str.pass.cpp   | 7 +++----
 test/std/re/re.submatch/re.submatch.op/compare.pass.cpp    | 7 +++----
 test/std/re/re.submatch/re.submatch.op/stream.pass.cpp     | 7 +++----
 test/std/re/re.submatch/types.pass.cpp                     | 7 +++----
 test/std/re/re.syn/cmatch.pass.cpp                         | 7 +++----
 test/std/re/re.syn/cregex_iterator.pass.cpp                | 7 +++----
 test/std/re/re.syn/cregex_token_iterator.pass.cpp          | 7 +++----
 test/std/re/re.syn/csub_match.pass.cpp                     | 7 +++----
 test/std/re/re.syn/regex.pass.cpp                          | 7 +++----
 test/std/re/re.syn/smatch.pass.cpp                         | 7 +++----
 test/std/re/re.syn/sregex_iterator.pass.cpp                | 7 +++----
 test/std/re/re.syn/sregex_token_iterator.pass.cpp          | 7 +++----
 test/std/re/re.syn/ssub_match.pass.cpp                     | 7 +++----
 test/std/re/re.syn/wcmatch.pass.cpp                        | 7 +++----
 test/std/re/re.syn/wcregex_iterator.pass.cpp               | 7 +++----
 test/std/re/re.syn/wcregex_token_iterator.pass.cpp         | 7 +++----
 test/std/re/re.syn/wcsub_match.pass.cpp                    | 7 +++----
 test/std/re/re.syn/wregex.pass.cpp                         | 7 +++----
 test/std/re/re.syn/wsmatch.pass.cpp                        | 7 +++----
 test/std/re/re.syn/wsregex_iterator.pass.cpp               | 7 +++----
 test/std/re/re.syn/wsregex_token_iterator.pass.cpp         | 7 +++----
 test/std/re/re.syn/wssub_match.pass.cpp                    | 7 +++----
 test/std/re/re.traits/default.pass.cpp                     | 7 +++----
 test/std/re/re.traits/getloc.pass.cpp                      | 7 +++----
 test/std/re/re.traits/imbue.pass.cpp                       | 7 +++----
 test/std/re/re.traits/isctype.pass.cpp                     | 7 +++----
 test/std/re/re.traits/length.pass.cpp                      | 7 +++----
 test/std/re/re.traits/lookup_classname.pass.cpp            | 7 +++----
 test/std/re/re.traits/lookup_collatename.pass.cpp          | 7 +++----
 test/std/re/re.traits/transform.pass.cpp                   | 7 +++----
 test/std/re/re.traits/transform_primary.pass.cpp           | 7 +++----
 test/std/re/re.traits/translate.pass.cpp                   | 7 +++----
 test/std/re/re.traits/translate_nocase.pass.cpp            | 7 +++----
 test/std/re/re.traits/types.pass.cpp                       | 7 +++----
 test/std/re/re.traits/value.pass.cpp                       | 7 +++----
 test/std/strings/basic.string.hash/enabled_hashes.pass.cpp | 7 +++----
 test/std/strings/basic.string.hash/strings.pass.cpp        | 7 +++----
 test/std/strings/basic.string.literals/literal.pass.cpp    | 7 +++----
 test/std/strings/basic.string.literals/literal1.fail.cpp   | 7 +++----
 test/std/strings/basic.string.literals/literal1.pass.cpp   | 7 +++----
 test/std/strings/basic.string.literals/literal2.fail.cpp   | 7 +++----
 test/std/strings/basic.string.literals/literal2.pass.cpp   | 7 +++----
 test/std/strings/basic.string.literals/literal3.pass.cpp   | 7 +++----
 test/std/strings/basic.string/allocator_mismatch.fail.cpp  | 7 +++----
 test/std/strings/basic.string/char.bad.fail.cpp            | 7 +++----
 test/std/strings/basic.string/input_iterator.h             | 7 +++----
 test/std/strings/basic.string/string.access/at.pass.cpp    | 7 +++----
 test/std/strings/basic.string/string.access/back.pass.cpp  | 7 +++----
 .../strings/basic.string/string.access/db_back.pass.cpp    | 7 +++----
 .../strings/basic.string/string.access/db_cback.pass.cpp   | 7 +++----
 .../strings/basic.string/string.access/db_cfront.pass.cpp  | 7 +++----
 .../strings/basic.string/string.access/db_cindex.pass.cpp  | 7 +++----
 .../strings/basic.string/string.access/db_front.pass.cpp   | 7 +++----
 .../strings/basic.string/string.access/db_index.pass.cpp   | 7 +++----
 test/std/strings/basic.string/string.access/front.pass.cpp | 7 +++----
 test/std/strings/basic.string/string.access/index.pass.cpp | 7 +++----
 .../strings/basic.string/string.capacity/capacity.pass.cpp | 7 +++----
 .../strings/basic.string/string.capacity/clear.pass.cpp    | 7 +++----
 .../strings/basic.string/string.capacity/empty.fail.cpp    | 7 +++----
 .../strings/basic.string/string.capacity/empty.pass.cpp    | 7 +++----
 .../strings/basic.string/string.capacity/length.pass.cpp   | 7 +++----
 .../strings/basic.string/string.capacity/max_size.pass.cpp | 7 +++----
 .../basic.string/string.capacity/over_max_size.pass.cpp    | 7 +++----
 .../strings/basic.string/string.capacity/reserve.pass.cpp  | 7 +++----
 .../basic.string/string.capacity/resize_size.pass.cpp      | 7 +++----
 .../basic.string/string.capacity/resize_size_char.pass.cpp | 7 +++----
 .../basic.string/string.capacity/shrink_to_fit.pass.cpp    | 7 +++----
 .../std/strings/basic.string/string.capacity/size.pass.cpp | 7 +++----
 .../strings/basic.string/string.cons/T_size_size.pass.cpp  | 7 +++----
 test/std/strings/basic.string/string.cons/alloc.pass.cpp   | 7 +++----
 .../basic.string/string.cons/brace_assignment.pass.cpp     | 7 +++----
 .../basic.string/string.cons/char_assignment.pass.cpp      | 7 +++----
 test/std/strings/basic.string/string.cons/copy.pass.cpp    | 7 +++----
 .../strings/basic.string/string.cons/copy_alloc.pass.cpp   | 7 +++----
 .../basic.string/string.cons/copy_assignment.pass.cpp      | 7 +++----
 .../basic.string/string.cons/default_noexcept.pass.cpp     | 7 +++----
 .../basic.string/string.cons/dtor_noexcept.pass.cpp        | 7 +++----
 .../string.cons/implicit_deduction_guides.pass.cpp         | 7 +++----
 .../basic.string/string.cons/initializer_list.pass.cpp     | 7 +++----
 .../string.cons/initializer_list_assignment.pass.cpp       | 7 +++----
 .../strings/basic.string/string.cons/iter_alloc.pass.cpp   | 7 +++----
 .../basic.string/string.cons/iter_alloc_deduction.fail.cpp | 7 +++----
 .../basic.string/string.cons/iter_alloc_deduction.pass.cpp | 7 +++----
 test/std/strings/basic.string/string.cons/move.pass.cpp    | 7 +++----
 .../strings/basic.string/string.cons/move_alloc.pass.cpp   | 7 +++----
 .../basic.string/string.cons/move_assign_noexcept.pass.cpp | 7 +++----
 .../basic.string/string.cons/move_assignment.pass.cpp      | 7 +++----
 .../basic.string/string.cons/move_noexcept.pass.cpp        | 7 +++----
 .../basic.string/string.cons/pointer_alloc.pass.cpp        | 7 +++----
 .../basic.string/string.cons/pointer_assignment.pass.cpp   | 7 +++----
 .../basic.string/string.cons/pointer_size_alloc.pass.cpp   | 7 +++----
 .../basic.string/string.cons/size_char_alloc.pass.cpp      | 7 +++----
 .../strings/basic.string/string.cons/string_view.fail.cpp  | 7 +++----
 .../strings/basic.string/string.cons/string_view.pass.cpp  | 7 +++----
 .../string.cons/string_view_assignment.pass.cpp            | 7 +++----
 .../string.cons/string_view_deduction.fail.cpp             | 7 +++----
 .../string.cons/string_view_deduction.pass.cpp             | 7 +++----
 .../string.cons/string_view_size_size_deduction.fail.cpp   | 7 +++----
 .../string.cons/string_view_size_size_deduction.pass.cpp   | 7 +++----
 test/std/strings/basic.string/string.cons/substr.pass.cpp  | 7 +++----
 .../basic.string/string.ends_with/ends_with.char.pass.cpp  | 7 +++----
 .../basic.string/string.ends_with/ends_with.ptr.pass.cpp   | 7 +++----
 .../string.ends_with/ends_with.string_view.pass.cpp        | 7 +++----
 .../strings/basic.string/string.iterators/begin.pass.cpp   | 7 +++----
 .../strings/basic.string/string.iterators/cbegin.pass.cpp  | 7 +++----
 .../strings/basic.string/string.iterators/cend.pass.cpp    | 7 +++----
 .../strings/basic.string/string.iterators/crbegin.pass.cpp | 7 +++----
 .../strings/basic.string/string.iterators/crend.pass.cpp   | 7 +++----
 .../basic.string/string.iterators/db_iterators_2.pass.cpp  | 7 +++----
 .../basic.string/string.iterators/db_iterators_3.pass.cpp  | 7 +++----
 .../basic.string/string.iterators/db_iterators_4.pass.cpp  | 7 +++----
 .../basic.string/string.iterators/db_iterators_5.pass.cpp  | 7 +++----
 .../basic.string/string.iterators/db_iterators_6.pass.cpp  | 7 +++----
 .../basic.string/string.iterators/db_iterators_7.pass.cpp  | 7 +++----
 .../basic.string/string.iterators/db_iterators_8.pass.cpp  | 7 +++----
 .../std/strings/basic.string/string.iterators/end.pass.cpp | 7 +++----
 .../basic.string/string.iterators/iterators.pass.cpp       | 7 +++----
 .../strings/basic.string/string.iterators/rbegin.pass.cpp  | 7 +++----
 .../strings/basic.string/string.iterators/rend.pass.cpp    | 7 +++----
 .../basic.string/string.modifiers/nothing_to_do.pass.cpp   | 7 +++----
 .../string.modifiers/string_append/T_size_size.pass.cpp    | 7 +++----
 .../string_append/initializer_list.pass.cpp                | 7 +++----
 .../string.modifiers/string_append/iterator.pass.cpp       | 7 +++----
 .../string.modifiers/string_append/pointer.pass.cpp        | 7 +++----
 .../string.modifiers/string_append/pointer_size.pass.cpp   | 7 +++----
 .../string.modifiers/string_append/push_back.pass.cpp      | 7 +++----
 .../string.modifiers/string_append/size_char.pass.cpp      | 7 +++----
 .../string.modifiers/string_append/string.pass.cpp         | 7 +++----
 .../string_append/string_size_size.pass.cpp                | 7 +++----
 .../string.modifiers/string_append/string_view.pass.cpp    | 7 +++----
 .../string.modifiers/string_assign/T_size_size.pass.cpp    | 7 +++----
 .../string_assign/initializer_list.pass.cpp                | 7 +++----
 .../string.modifiers/string_assign/iterator.pass.cpp       | 7 +++----
 .../string.modifiers/string_assign/pointer.pass.cpp        | 7 +++----
 .../string.modifiers/string_assign/pointer_size.pass.cpp   | 7 +++----
 .../string.modifiers/string_assign/rv_string.pass.cpp      | 7 +++----
 .../string.modifiers/string_assign/size_char.pass.cpp      | 7 +++----
 .../string.modifiers/string_assign/string.pass.cpp         | 7 +++----
 .../string_assign/string_size_size.pass.cpp                | 7 +++----
 .../string.modifiers/string_assign/string_view.pass.cpp    | 7 +++----
 .../string.modifiers/string_copy/copy.pass.cpp             | 7 +++----
 .../string.modifiers/string_erase/iter.pass.cpp            | 7 +++----
 .../string.modifiers/string_erase/iter_iter.pass.cpp       | 7 +++----
 .../string.modifiers/string_erase/pop_back.pass.cpp        | 7 +++----
 .../string.modifiers/string_erase/size_size.pass.cpp       | 7 +++----
 .../string.modifiers/string_insert/iter_char.pass.cpp      | 7 +++----
 .../string_insert/iter_initializer_list.pass.cpp           | 7 +++----
 .../string.modifiers/string_insert/iter_iter_iter.pass.cpp | 7 +++----
 .../string.modifiers/string_insert/iter_size_char.pass.cpp | 7 +++----
 .../string_insert/size_T_size_size.pass.cpp                | 7 +++----
 .../string.modifiers/string_insert/size_pointer.pass.cpp   | 7 +++----
 .../string_insert/size_pointer_size.pass.cpp               | 7 +++----
 .../string.modifiers/string_insert/size_size_char.pass.cpp | 7 +++----
 .../string.modifiers/string_insert/size_string.pass.cpp    | 7 +++----
 .../string_insert/size_string_size_size.pass.cpp           | 7 +++----
 .../string.modifiers/string_insert/string_view.pass.cpp    | 7 +++----
 .../string.modifiers/string_op_plus_equal/char.pass.cpp    | 7 +++----
 .../string_op_plus_equal/initializer_list.pass.cpp         | 7 +++----
 .../string.modifiers/string_op_plus_equal/pointer.pass.cpp | 7 +++----
 .../string.modifiers/string_op_plus_equal/string.pass.cpp  | 7 +++----
 .../string_replace/iter_iter_initializer_list.pass.cpp     | 7 +++----
 .../string_replace/iter_iter_iter_iter.pass.cpp            | 7 +++----
 .../string_replace/iter_iter_pointer.pass.cpp              | 7 +++----
 .../string_replace/iter_iter_pointer_size.pass.cpp         | 7 +++----
 .../string_replace/iter_iter_size_char.pass.cpp            | 7 +++----
 .../string_replace/iter_iter_string.pass.cpp               | 7 +++----
 .../string_replace/iter_iter_string_view.pass.cpp          | 7 +++----
 .../string_replace/size_size_T_size_size.pass.cpp          | 7 +++----
 .../string_replace/size_size_pointer.pass.cpp              | 7 +++----
 .../string_replace/size_size_pointer_size.pass.cpp         | 7 +++----
 .../string_replace/size_size_size_char.pass.cpp            | 7 +++----
 .../string_replace/size_size_string.pass.cpp               | 7 +++----
 .../string_replace/size_size_string_size_size.pass.cpp     | 7 +++----
 .../string_replace/size_size_string_view.pass.cpp          | 7 +++----
 .../string.modifiers/string_swap/swap.pass.cpp             | 7 +++----
 .../basic.string/string.nonmembers/nothing_to_do.pass.cpp  | 7 +++----
 .../string.nonmembers/string.io/get_line.pass.cpp          | 7 +++----
 .../string.nonmembers/string.io/get_line_delim.pass.cpp    | 7 +++----
 .../string.nonmembers/string.io/get_line_delim_rv.pass.cpp | 7 +++----
 .../string.nonmembers/string.io/get_line_rv.pass.cpp       | 7 +++----
 .../string.nonmembers/string.io/stream_extract.pass.cpp    | 7 +++----
 .../string.nonmembers/string.io/stream_insert.pass.cpp     | 7 +++----
 .../string.nonmembers/string.special/swap.pass.cpp         | 7 +++----
 .../string.special/swap_noexcept.pass.cpp                  | 7 +++----
 .../string.nonmembers/string_op!=/pointer_string.pass.cpp  | 7 +++----
 .../string.nonmembers/string_op!=/string_pointer.pass.cpp  | 7 +++----
 .../string.nonmembers/string_op!=/string_string.pass.cpp   | 7 +++----
 .../string_op!=/string_string_view.pass.cpp                | 7 +++----
 .../string_op!=/string_view_string.pass.cpp                | 7 +++----
 .../string.nonmembers/string_op+/char_string.pass.cpp      | 7 +++----
 .../string.nonmembers/string_op+/pointer_string.pass.cpp   | 7 +++----
 .../string.nonmembers/string_op+/string_char.pass.cpp      | 7 +++----
 .../string.nonmembers/string_op+/string_pointer.pass.cpp   | 7 +++----
 .../string.nonmembers/string_op+/string_string.pass.cpp    | 7 +++----
 .../string_operator==/pointer_string.pass.cpp              | 7 +++----
 .../string_operator==/string_pointer.pass.cpp              | 7 +++----
 .../string_operator==/string_string.pass.cpp               | 7 +++----
 .../string_operator==/string_string_view.pass.cpp          | 7 +++----
 .../string_operator==/string_view_string.pass.cpp          | 7 +++----
 .../string.nonmembers/string_opgt/pointer_string.pass.cpp  | 7 +++----
 .../string.nonmembers/string_opgt/string_pointer.pass.cpp  | 7 +++----
 .../string.nonmembers/string_opgt/string_string.pass.cpp   | 7 +++----
 .../string_opgt/string_string_view.pass.cpp                | 7 +++----
 .../string_opgt/string_view_string.pass.cpp                | 7 +++----
 .../string.nonmembers/string_opgt=/pointer_string.pass.cpp | 7 +++----
 .../string.nonmembers/string_opgt=/string_pointer.pass.cpp | 7 +++----
 .../string.nonmembers/string_opgt=/string_string.pass.cpp  | 7 +++----
 .../string_opgt=/string_string_view.pass.cpp               | 7 +++----
 .../string_opgt=/string_view_string.pass.cpp               | 7 +++----
 .../string.nonmembers/string_oplt/pointer_string.pass.cpp  | 7 +++----
 .../string.nonmembers/string_oplt/string_pointer.pass.cpp  | 7 +++----
 .../string.nonmembers/string_oplt/string_string.pass.cpp   | 7 +++----
 .../string_oplt/string_string_view.pass.cpp                | 7 +++----
 .../string_oplt/string_view_string.pass.cpp                | 7 +++----
 .../string.nonmembers/string_oplt=/pointer_string.pass.cpp | 7 +++----
 .../string.nonmembers/string_oplt=/string_pointer.pass.cpp | 7 +++----
 .../string.nonmembers/string_oplt=/string_string.pass.cpp  | 7 +++----
 .../string_oplt=/string_string_view.pass.cpp               | 7 +++----
 .../string_oplt=/string_view_string.pass.cpp               | 7 +++----
 .../strings/basic.string/string.ops/nothing_to_do.pass.cpp | 7 +++----
 .../string.ops/string.accessors/c_str.pass.cpp             | 7 +++----
 .../basic.string/string.ops/string.accessors/data.pass.cpp | 7 +++----
 .../string.ops/string.accessors/get_allocator.pass.cpp     | 7 +++----
 .../string.ops/string_compare/pointer.pass.cpp             | 7 +++----
 .../string_compare/size_size_T_size_size.pass.cpp          | 7 +++----
 .../string.ops/string_compare/size_size_pointer.pass.cpp   | 7 +++----
 .../string_compare/size_size_pointer_size.pass.cpp         | 7 +++----
 .../string.ops/string_compare/size_size_string.pass.cpp    | 7 +++----
 .../string_compare/size_size_string_size_size.pass.cpp     | 7 +++----
 .../string_compare/size_size_string_view.pass.cpp          | 7 +++----
 .../basic.string/string.ops/string_compare/string.pass.cpp | 7 +++----
 .../string.ops/string_compare/string_view.pass.cpp         | 7 +++----
 .../string.ops/string_find.first.not.of/char_size.pass.cpp | 7 +++----
 .../string_find.first.not.of/pointer_size.pass.cpp         | 7 +++----
 .../string_find.first.not.of/pointer_size_size.pass.cpp    | 7 +++----
 .../string_find.first.not.of/string_size.pass.cpp          | 7 +++----
 .../string_find.first.not.of/string_view_size.pass.cpp     | 7 +++----
 .../string.ops/string_find.first.of/char_size.pass.cpp     | 7 +++----
 .../string.ops/string_find.first.of/pointer_size.pass.cpp  | 7 +++----
 .../string_find.first.of/pointer_size_size.pass.cpp        | 7 +++----
 .../string.ops/string_find.first.of/string_size.pass.cpp   | 7 +++----
 .../string_find.first.of/string_view_size.pass.cpp         | 7 +++----
 .../string.ops/string_find.last.not.of/char_size.pass.cpp  | 7 +++----
 .../string_find.last.not.of/pointer_size.pass.cpp          | 7 +++----
 .../string_find.last.not.of/pointer_size_size.pass.cpp     | 7 +++----
 .../string_find.last.not.of/string_size.pass.cpp           | 7 +++----
 .../string_find.last.not.of/string_view_size.pass.cpp      | 7 +++----
 .../string.ops/string_find.last.of/char_size.pass.cpp      | 7 +++----
 .../string.ops/string_find.last.of/pointer_size.pass.cpp   | 7 +++----
 .../string_find.last.of/pointer_size_size.pass.cpp         | 7 +++----
 .../string.ops/string_find.last.of/string_size.pass.cpp    | 7 +++----
 .../string_find.last.of/string_view_size.pass.cpp          | 7 +++----
 .../basic.string/string.ops/string_find/char_size.pass.cpp | 7 +++----
 .../string.ops/string_find/pointer_size.pass.cpp           | 7 +++----
 .../string.ops/string_find/pointer_size_size.pass.cpp      | 7 +++----
 .../string.ops/string_find/string_size.pass.cpp            | 7 +++----
 .../string.ops/string_find/string_view_size.pass.cpp       | 7 +++----
 .../string.ops/string_rfind/char_size.pass.cpp             | 7 +++----
 .../string.ops/string_rfind/pointer_size.pass.cpp          | 7 +++----
 .../string.ops/string_rfind/pointer_size_size.pass.cpp     | 7 +++----
 .../string.ops/string_rfind/string_size.pass.cpp           | 7 +++----
 .../string.ops/string_rfind/string_view_size.pass.cpp      | 7 +++----
 .../basic.string/string.ops/string_substr/substr.pass.cpp  | 7 +++----
 .../basic.string/string.require/contiguous.pass.cpp        | 7 +++----
 .../string.starts_with/starts_with.char.pass.cpp           | 7 +++----
 .../string.starts_with/starts_with.ptr.pass.cpp            | 7 +++----
 .../string.starts_with/starts_with.string_view.pass.cpp    | 7 +++----
 test/std/strings/basic.string/test_traits.h                | 7 +++----
 test/std/strings/basic.string/traits_mismatch.fail.cpp     | 7 +++----
 test/std/strings/basic.string/types.pass.cpp               | 7 +++----
 test/std/strings/c.strings/cctype.pass.cpp                 | 7 +++----
 test/std/strings/c.strings/cstring.pass.cpp                | 7 +++----
 test/std/strings/c.strings/cuchar.pass.cpp                 | 7 +++----
 test/std/strings/c.strings/cwchar.pass.cpp                 | 7 +++----
 test/std/strings/c.strings/cwctype.pass.cpp                | 7 +++----
 .../char.traits/char.traits.require/nothing_to_do.pass.cpp | 7 +++----
 .../char.traits.specializations.char/assign2.pass.cpp      | 7 +++----
 .../char.traits.specializations.char/assign3.pass.cpp      | 7 +++----
 .../char.traits.specializations.char/compare.pass.cpp      | 7 +++----
 .../char.traits.specializations.char/copy.pass.cpp         | 7 +++----
 .../char.traits.specializations.char/eof.pass.cpp          | 7 +++----
 .../char.traits.specializations.char/eq.pass.cpp           | 7 +++----
 .../char.traits.specializations.char/eq_int_type.pass.cpp  | 7 +++----
 .../char.traits.specializations.char/find.pass.cpp         | 7 +++----
 .../char.traits.specializations.char/length.pass.cpp       | 7 +++----
 .../char.traits.specializations.char/lt.pass.cpp           | 7 +++----
 .../char.traits.specializations.char/move.pass.cpp         | 7 +++----
 .../char.traits.specializations.char/not_eof.pass.cpp      | 7 +++----
 .../char.traits.specializations.char/to_char_type.pass.cpp | 7 +++----
 .../char.traits.specializations.char/to_int_type.pass.cpp  | 7 +++----
 .../char.traits.specializations.char/types.pass.cpp        | 7 +++----
 .../char.traits.specializations.char16_t/assign2.pass.cpp  | 7 +++----
 .../char.traits.specializations.char16_t/assign3.pass.cpp  | 7 +++----
 .../char.traits.specializations.char16_t/compare.pass.cpp  | 7 +++----
 .../char.traits.specializations.char16_t/copy.pass.cpp     | 7 +++----
 .../char.traits.specializations.char16_t/eof.pass.cpp      | 7 +++----
 .../char.traits.specializations.char16_t/eq.pass.cpp       | 7 +++----
 .../eq_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.char16_t/find.pass.cpp     | 7 +++----
 .../char.traits.specializations.char16_t/length.pass.cpp   | 7 +++----
 .../char.traits.specializations.char16_t/lt.pass.cpp       | 7 +++----
 .../char.traits.specializations.char16_t/move.pass.cpp     | 7 +++----
 .../char.traits.specializations.char16_t/not_eof.pass.cpp  | 7 +++----
 .../to_char_type.pass.cpp                                  | 7 +++----
 .../to_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.char16_t/types.pass.cpp    | 7 +++----
 .../char.traits.specializations.char32_t/assign2.pass.cpp  | 7 +++----
 .../char.traits.specializations.char32_t/assign3.pass.cpp  | 7 +++----
 .../char.traits.specializations.char32_t/compare.pass.cpp  | 7 +++----
 .../char.traits.specializations.char32_t/copy.pass.cpp     | 7 +++----
 .../char.traits.specializations.char32_t/eof.pass.cpp      | 7 +++----
 .../char.traits.specializations.char32_t/eq.pass.cpp       | 7 +++----
 .../eq_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.char32_t/find.pass.cpp     | 7 +++----
 .../char.traits.specializations.char32_t/length.pass.cpp   | 7 +++----
 .../char.traits.specializations.char32_t/lt.pass.cpp       | 7 +++----
 .../char.traits.specializations.char32_t/move.pass.cpp     | 7 +++----
 .../char.traits.specializations.char32_t/not_eof.pass.cpp  | 7 +++----
 .../to_char_type.pass.cpp                                  | 7 +++----
 .../to_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.char32_t/types.pass.cpp    | 7 +++----
 .../char.traits.specializations.char8_t/assign2.pass.cpp   | 7 +++----
 .../char.traits.specializations.char8_t/assign3.pass.cpp   | 7 +++----
 .../char.traits.specializations.char8_t/compare.pass.cpp   | 7 +++----
 .../char.traits.specializations.char8_t/copy.pass.cpp      | 7 +++----
 .../char.traits.specializations.char8_t/eof.pass.cpp       | 7 +++----
 .../char.traits.specializations.char8_t/eq.pass.cpp        | 7 +++----
 .../eq_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.char8_t/find.pass.cpp      | 7 +++----
 .../char.traits.specializations.char8_t/length.pass.cpp    | 7 +++----
 .../char.traits.specializations.char8_t/lt.pass.cpp        | 7 +++----
 .../char.traits.specializations.char8_t/move.pass.cpp      | 7 +++----
 .../char.traits.specializations.char8_t/not_eof.pass.cpp   | 7 +++----
 .../to_char_type.pass.cpp                                  | 7 +++----
 .../to_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.char8_t/types.pass.cpp     | 7 +++----
 .../char.traits.specializations.wchar.t/assign2.pass.cpp   | 7 +++----
 .../char.traits.specializations.wchar.t/assign3.pass.cpp   | 7 +++----
 .../char.traits.specializations.wchar.t/compare.pass.cpp   | 7 +++----
 .../char.traits.specializations.wchar.t/copy.pass.cpp      | 7 +++----
 .../char.traits.specializations.wchar.t/eof.pass.cpp       | 7 +++----
 .../char.traits.specializations.wchar.t/eq.pass.cpp        | 7 +++----
 .../eq_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.wchar.t/find.pass.cpp      | 7 +++----
 .../char.traits.specializations.wchar.t/length.pass.cpp    | 7 +++----
 .../char.traits.specializations.wchar.t/lt.pass.cpp        | 7 +++----
 .../char.traits.specializations.wchar.t/move.pass.cpp      | 7 +++----
 .../char.traits.specializations.wchar.t/not_eof.pass.cpp   | 7 +++----
 .../to_char_type.pass.cpp                                  | 7 +++----
 .../to_int_type.pass.cpp                                   | 7 +++----
 .../char.traits.specializations.wchar.t/types.pass.cpp     | 7 +++----
 .../char.traits.specializations/nothing_to_do.pass.cpp     | 7 +++----
 .../char.traits.typedefs/nothing_to_do.pass.cpp            | 7 +++----
 test/std/strings/char.traits/nothing_to_do.pass.cpp        | 7 +++----
 test/std/strings/string.classes/typedefs.pass.cpp          | 7 +++----
 test/std/strings/string.conversions/stod.pass.cpp          | 7 +++----
 test/std/strings/string.conversions/stof.pass.cpp          | 7 +++----
 test/std/strings/string.conversions/stoi.pass.cpp          | 7 +++----
 test/std/strings/string.conversions/stol.pass.cpp          | 7 +++----
 test/std/strings/string.conversions/stold.pass.cpp         | 7 +++----
 test/std/strings/string.conversions/stoll.pass.cpp         | 7 +++----
 test/std/strings/string.conversions/stoul.pass.cpp         | 7 +++----
 test/std/strings/string.conversions/stoull.pass.cpp        | 7 +++----
 test/std/strings/string.conversions/to_string.pass.cpp     | 7 +++----
 test/std/strings/string.conversions/to_wstring.pass.cpp    | 7 +++----
 test/std/strings/string.view/char.bad.fail.cpp             | 7 +++----
 .../std/strings/string.view/string.view.access/at.pass.cpp | 7 +++----
 .../strings/string.view/string.view.access/back.pass.cpp   | 7 +++----
 .../strings/string.view/string.view.access/data.pass.cpp   | 7 +++----
 .../strings/string.view/string.view.access/front.pass.cpp  | 7 +++----
 .../strings/string.view/string.view.access/index.pass.cpp  | 7 +++----
 .../string.view/string.view.capacity/capacity.pass.cpp     | 7 +++----
 .../string.view/string.view.capacity/empty.fail.cpp        | 7 +++----
 .../opeq.string_view.pointer.pass.cpp                      | 7 +++----
 .../opeq.string_view.string.pass.cpp                       | 7 +++----
 .../opeq.string_view.string_view.pass.cpp                  | 7 +++----
 .../opge.string_view.pointer.pass.cpp                      | 7 +++----
 .../opge.string_view.string.pass.cpp                       | 7 +++----
 .../opge.string_view.string_view.pass.cpp                  | 7 +++----
 .../opgt.string_view.pointer.pass.cpp                      | 7 +++----
 .../opgt.string_view.string.pass.cpp                       | 7 +++----
 .../opgt.string_view.string_view.pass.cpp                  | 7 +++----
 .../ople.string_view.pointer.pass.cpp                      | 7 +++----
 .../ople.string_view.string.pass.cpp                       | 7 +++----
 .../ople.string_view.string_view.pass.cpp                  | 7 +++----
 .../oplt.string_view.pointer.pass.cpp                      | 7 +++----
 .../oplt.string_view.string.pass.cpp                       | 7 +++----
 .../oplt.string_view.string_view.pass.cpp                  | 7 +++----
 .../opne.string_view.pointer.pass.cpp                      | 7 +++----
 .../opne.string_view.string.pass.cpp                       | 7 +++----
 .../opne.string_view.string_view.pass.cpp                  | 7 +++----
 .../strings/string.view/string.view.cons/assign.pass.cpp   | 7 +++----
 .../strings/string.view/string.view.cons/default.pass.cpp  | 7 +++----
 .../string.view/string.view.cons/from_literal.pass.cpp     | 7 +++----
 .../string.view/string.view.cons/from_ptr_len.pass.cpp     | 7 +++----
 .../string.view/string.view.cons/from_string.pass.cpp      | 7 +++----
 .../string.view/string.view.cons/from_string1.fail.cpp     | 7 +++----
 .../string.view/string.view.cons/from_string2.fail.cpp     | 7 +++----
 .../string.view.cons/implicit_deduction_guides.pass.cpp    | 7 +++----
 .../string.view/string.view.find/find_char_size.pass.cpp   | 7 +++----
 .../string.view.find/find_first_not_of_char_size.pass.cpp  | 7 +++----
 .../find_first_not_of_pointer_size.pass.cpp                | 7 +++----
 .../find_first_not_of_pointer_size_size.pass.cpp           | 7 +++----
 .../find_first_not_of_string_view_size.pass.cpp            | 7 +++----
 .../string.view.find/find_first_of_char_size.pass.cpp      | 7 +++----
 .../string.view.find/find_first_of_pointer_size.pass.cpp   | 7 +++----
 .../find_first_of_pointer_size_size.pass.cpp               | 7 +++----
 .../find_first_of_string_view_size.pass.cpp                | 7 +++----
 .../string.view.find/find_last_not_of_char_size.pass.cpp   | 7 +++----
 .../find_last_not_of_pointer_size.pass.cpp                 | 7 +++----
 .../find_last_not_of_pointer_size_size.pass.cpp            | 7 +++----
 .../find_last_not_of_string_view_size.pass.cpp             | 7 +++----
 .../string.view.find/find_last_of_char_size.pass.cpp       | 7 +++----
 .../string.view.find/find_last_of_pointer_size.pass.cpp    | 7 +++----
 .../find_last_of_pointer_size_size.pass.cpp                | 7 +++----
 .../find_last_of_string_view_size.pass.cpp                 | 7 +++----
 .../string.view.find/find_pointer_size.pass.cpp            | 7 +++----
 .../string.view.find/find_pointer_size_size.pass.cpp       | 7 +++----
 .../string.view.find/find_string_view_size.pass.cpp        | 7 +++----
 .../string.view/string.view.find/rfind_char_size.pass.cpp  | 7 +++----
 .../string.view.find/rfind_pointer_size.pass.cpp           | 7 +++----
 .../string.view.find/rfind_pointer_size_size.pass.cpp      | 7 +++----
 .../string.view.find/rfind_string_view_size.pass.cpp       | 7 +++----
 .../string.view/string.view.hash/enabled_hashes.pass.cpp   | 7 +++----
 .../string.view/string.view.hash/string_view.pass.cpp      | 7 +++----
 .../string.view/string.view.io/stream_insert.pass.cpp      | 7 +++----
 .../string.view/string.view.iterators/begin.pass.cpp       | 7 +++----
 .../strings/string.view/string.view.iterators/end.pass.cpp | 7 +++----
 .../string.view/string.view.iterators/rbegin.pass.cpp      | 7 +++----
 .../string.view/string.view.iterators/rend.pass.cpp        | 7 +++----
 .../string.view.modifiers/remove_prefix.pass.cpp           | 7 +++----
 .../string.view.modifiers/remove_suffix.pass.cpp           | 7 +++----
 .../string.view/string.view.modifiers/swap.pass.cpp        | 7 +++----
 .../strings/string.view/string.view.nonmem/quoted.pass.cpp | 7 +++----
 .../string.view/string.view.ops/compare.pointer.pass.cpp   | 7 +++----
 .../string.view.ops/compare.pointer_size.pass.cpp          | 7 +++----
 .../string.view.ops/compare.size_size_sv.pass.cpp          | 7 +++----
 .../compare.size_size_sv_pointer_size.pass.cpp             | 7 +++----
 .../compare.size_size_sv_size_size.pass.cpp                | 7 +++----
 .../string.view/string.view.ops/compare.sv.pass.cpp        | 7 +++----
 test/std/strings/string.view/string.view.ops/copy.pass.cpp | 7 +++----
 .../strings/string.view/string.view.ops/substr.pass.cpp    | 7 +++----
 .../string.view/string.view.synop/nothing_to_do.pass.cpp   | 7 +++----
 .../string.view.template/ends_with.char.pass.cpp           | 7 +++----
 .../string.view.template/ends_with.ptr.pass.cpp            | 7 +++----
 .../string.view.template/ends_with.string_view.pass.cpp    | 7 +++----
 .../string.view.template/nothing_to_do.pass.cpp            | 7 +++----
 .../string.view.template/starts_with.char.pass.cpp         | 7 +++----
 .../string.view.template/starts_with.ptr.pass.cpp          | 7 +++----
 .../string.view.template/starts_with.string_view.pass.cpp  | 7 +++----
 .../string.view/string_view.literals/literal.pass.cpp      | 7 +++----
 .../string.view/string_view.literals/literal1.fail.cpp     | 7 +++----
 .../string.view/string_view.literals/literal1.pass.cpp     | 7 +++----
 .../string.view/string_view.literals/literal2.fail.cpp     | 7 +++----
 .../string.view/string_view.literals/literal2.pass.cpp     | 7 +++----
 .../string.view/string_view.literals/literal3.pass.cpp     | 7 +++----
 test/std/strings/string.view/traits_mismatch.fail.cpp      | 7 +++----
 test/std/strings/string.view/types.pass.cpp                | 7 +++----
 test/std/strings/strings.erasure/erase.pass.cpp            | 7 +++----
 test/std/strings/strings.erasure/erase_if.pass.cpp         | 7 +++----
 test/std/strings/strings.general/nothing_to_do.pass.cpp    | 7 +++----
 test/std/thread/futures/futures.async/async.fail.cpp       | 7 +++----
 test/std/thread/futures/futures.async/async.pass.cpp       | 7 +++----
 .../thread/futures/futures.async/async_race.38682.pass.cpp | 7 +++----
 test/std/thread/futures/futures.async/async_race.pass.cpp  | 7 +++----
 .../futures.errors/default_error_condition.pass.cpp        | 7 +++----
 .../futures.errors/equivalent_error_code_int.pass.cpp      | 7 +++----
 .../futures.errors/equivalent_int_error_condition.pass.cpp | 7 +++----
 .../thread/futures/futures.errors/future_category.pass.cpp | 7 +++----
 .../thread/futures/futures.errors/make_error_code.pass.cpp | 7 +++----
 .../futures/futures.errors/make_error_condition.pass.cpp   | 7 +++----
 test/std/thread/futures/futures.future_error/code.pass.cpp | 7 +++----
 .../std/thread/futures/futures.future_error/types.pass.cpp | 7 +++----
 test/std/thread/futures/futures.future_error/what.pass.cpp | 7 +++----
 .../thread/futures/futures.overview/future_errc.pass.cpp   | 7 +++----
 .../thread/futures/futures.overview/future_status.pass.cpp | 7 +++----
 .../is_error_code_enum_future_errc.pass.cpp                | 7 +++----
 test/std/thread/futures/futures.overview/launch.pass.cpp   | 7 +++----
 .../std/thread/futures/futures.promise/alloc_ctor.pass.cpp | 7 +++----
 .../thread/futures/futures.promise/copy_assign.fail.cpp    | 7 +++----
 test/std/thread/futures/futures.promise/copy_ctor.fail.cpp | 7 +++----
 test/std/thread/futures/futures.promise/default.pass.cpp   | 7 +++----
 test/std/thread/futures/futures.promise/dtor.pass.cpp      | 7 +++----
 .../std/thread/futures/futures.promise/get_future.pass.cpp | 7 +++----
 .../thread/futures/futures.promise/move_assign.pass.cpp    | 7 +++----
 test/std/thread/futures/futures.promise/move_ctor.pass.cpp | 7 +++----
 .../thread/futures/futures.promise/set_exception.pass.cpp  | 7 +++----
 .../futures.promise/set_exception_at_thread_exit.pass.cpp  | 7 +++----
 .../std/thread/futures/futures.promise/set_lvalue.pass.cpp | 7 +++----
 .../futures.promise/set_lvalue_at_thread_exit.pass.cpp     | 7 +++----
 .../std/thread/futures/futures.promise/set_rvalue.pass.cpp | 7 +++----
 .../futures.promise/set_rvalue_at_thread_exit.pass.cpp     | 7 +++----
 .../set_value_at_thread_exit_const.pass.cpp                | 7 +++----
 .../futures.promise/set_value_at_thread_exit_void.pass.cpp | 7 +++----
 .../futures/futures.promise/set_value_const.pass.cpp       | 7 +++----
 .../thread/futures/futures.promise/set_value_void.pass.cpp | 7 +++----
 test/std/thread/futures/futures.promise/swap.pass.cpp      | 7 +++----
 .../thread/futures/futures.promise/uses_allocator.pass.cpp | 7 +++----
 .../futures/futures.shared_future/copy_assign.pass.cpp     | 7 +++----
 .../futures/futures.shared_future/copy_ctor.pass.cpp       | 7 +++----
 .../futures/futures.shared_future/ctor_future.pass.cpp     | 7 +++----
 .../thread/futures/futures.shared_future/default.pass.cpp  | 7 +++----
 .../std/thread/futures/futures.shared_future/dtor.pass.cpp | 7 +++----
 test/std/thread/futures/futures.shared_future/get.pass.cpp | 7 +++----
 .../futures/futures.shared_future/move_assign.pass.cpp     | 7 +++----
 .../futures/futures.shared_future/move_ctor.pass.cpp       | 7 +++----
 .../std/thread/futures/futures.shared_future/wait.pass.cpp | 7 +++----
 .../thread/futures/futures.shared_future/wait_for.pass.cpp | 7 +++----
 .../futures/futures.shared_future/wait_until.pass.cpp      | 7 +++----
 .../thread/futures/futures.state/nothing_to_do.pass.cpp    | 7 +++----
 .../futures.task/futures.task.members/assign_copy.fail.cpp | 7 +++----
 .../futures.task/futures.task.members/assign_move.pass.cpp | 7 +++----
 .../futures.task/futures.task.members/ctor1.fail.cpp       | 7 +++----
 .../futures.task/futures.task.members/ctor2.fail.cpp       | 7 +++----
 .../futures.task/futures.task.members/ctor_copy.fail.cpp   | 7 +++----
 .../futures.task.members/ctor_default.pass.cpp             | 7 +++----
 .../futures.task/futures.task.members/ctor_func.pass.cpp   | 7 +++----
 .../futures.task.members/ctor_func_alloc.pass.cpp          | 7 +++----
 .../futures.task/futures.task.members/ctor_move.pass.cpp   | 7 +++----
 .../futures.task/futures.task.members/dtor.pass.cpp        | 7 +++----
 .../futures.task/futures.task.members/get_future.pass.cpp  | 7 +++----
 .../make_ready_at_thread_exit.pass.cpp                     | 7 +++----
 .../futures.task/futures.task.members/operator.pass.cpp    | 7 +++----
 .../futures.task/futures.task.members/reset.pass.cpp       | 7 +++----
 .../futures.task/futures.task.members/swap.pass.cpp        | 7 +++----
 .../futures.task/futures.task.nonmembers/swap.pass.cpp     | 7 +++----
 .../futures.task.nonmembers/uses_allocator.pass.cpp        | 7 +++----
 .../futures/futures.unique_future/copy_assign.fail.cpp     | 7 +++----
 .../futures/futures.unique_future/copy_ctor.fail.cpp       | 7 +++----
 .../thread/futures/futures.unique_future/default.pass.cpp  | 7 +++----
 .../std/thread/futures/futures.unique_future/dtor.pass.cpp | 7 +++----
 test/std/thread/futures/futures.unique_future/get.pass.cpp | 7 +++----
 .../futures/futures.unique_future/move_assign.pass.cpp     | 7 +++----
 .../futures/futures.unique_future/move_ctor.pass.cpp       | 7 +++----
 .../thread/futures/futures.unique_future/share.pass.cpp    | 7 +++----
 .../std/thread/futures/futures.unique_future/wait.pass.cpp | 7 +++----
 .../thread/futures/futures.unique_future/wait_for.pass.cpp | 7 +++----
 .../futures/futures.unique_future/wait_until.pass.cpp      | 7 +++----
 test/std/thread/macro.pass.cpp                             | 7 +++----
 test/std/thread/thread.condition/cv_status.pass.cpp        | 7 +++----
 .../thread.condition/notify_all_at_thread_exit.pass.cpp    | 7 +++----
 .../thread.condition.condvar/assign.fail.cpp               | 7 +++----
 .../thread.condition.condvar/copy.fail.cpp                 | 7 +++----
 .../thread.condition.condvar/default.pass.cpp              | 7 +++----
 .../thread.condition.condvar/destructor.pass.cpp           | 7 +++----
 .../thread.condition.condvar/notify_all.pass.cpp           | 7 +++----
 .../thread.condition.condvar/notify_one.pass.cpp           | 7 +++----
 .../thread.condition.condvar/wait.pass.cpp                 | 7 +++----
 .../thread.condition.condvar/wait_for.pass.cpp             | 7 +++----
 .../thread.condition.condvar/wait_for_pred.pass.cpp        | 7 +++----
 .../thread.condition.condvar/wait_pred.pass.cpp            | 7 +++----
 .../thread.condition.condvar/wait_until.pass.cpp           | 7 +++----
 .../thread.condition.condvar/wait_until_pred.pass.cpp      | 7 +++----
 .../thread.condition.condvarany/assign.fail.cpp            | 7 +++----
 .../thread.condition.condvarany/copy.fail.cpp              | 7 +++----
 .../thread.condition.condvarany/default.pass.cpp           | 7 +++----
 .../thread.condition.condvarany/destructor.pass.cpp        | 7 +++----
 .../thread.condition.condvarany/notify_all.pass.cpp        | 7 +++----
 .../thread.condition.condvarany/notify_one.pass.cpp        | 7 +++----
 .../thread.condition.condvarany/wait.pass.cpp              | 7 +++----
 .../thread.condition.condvarany/wait_for.pass.cpp          | 7 +++----
 .../thread.condition.condvarany/wait_for_pred.pass.cpp     | 7 +++----
 .../thread.condition.condvarany/wait_pred.pass.cpp         | 7 +++----
 .../thread.condition.condvarany/wait_terminates.sh.cpp     | 7 +++----
 .../thread.condition.condvarany/wait_until.pass.cpp        | 7 +++----
 .../thread.condition.condvarany/wait_until_pred.pass.cpp   | 7 +++----
 test/std/thread/thread.general/nothing_to_do.pass.cpp      | 7 +++----
 .../thread.mutex/thread.lock.algorithm/lock.pass.cpp       | 7 +++----
 .../thread.mutex/thread.lock.algorithm/try_lock.pass.cpp   | 7 +++----
 .../thread.lock/thread.lock.guard/adopt_lock.pass.cpp      | 7 +++----
 .../thread.lock/thread.lock.guard/assign.fail.cpp          | 7 +++----
 .../thread.lock/thread.lock.guard/copy.fail.cpp            | 7 +++----
 .../thread.lock/thread.lock.guard/mutex.fail.cpp           | 7 +++----
 .../thread.lock/thread.lock.guard/mutex.pass.cpp           | 7 +++----
 .../thread.lock/thread.lock.guard/types.pass.cpp           | 7 +++----
 .../thread.lock/thread.lock.scoped/adopt_lock.pass.cpp     | 7 +++----
 .../thread.lock/thread.lock.scoped/assign.fail.cpp         | 7 +++----
 .../thread.lock/thread.lock.scoped/copy.fail.cpp           | 7 +++----
 .../thread.lock/thread.lock.scoped/mutex.fail.cpp          | 7 +++----
 .../thread.lock/thread.lock.scoped/mutex.pass.cpp          | 7 +++----
 .../thread.lock/thread.lock.scoped/types.pass.cpp          | 7 +++----
 .../thread.lock.shared.cons/copy_assign.fail.cpp           | 7 +++----
 .../thread.lock.shared.cons/copy_ctor.fail.cpp             | 7 +++----
 .../thread.lock.shared.cons/default.pass.cpp               | 7 +++----
 .../thread.lock.shared.cons/move_assign.pass.cpp           | 7 +++----
 .../thread.lock.shared.cons/move_ctor.pass.cpp             | 7 +++----
 .../thread.lock.shared.cons/mutex.pass.cpp                 | 7 +++----
 .../thread.lock.shared.cons/mutex_adopt_lock.pass.cpp      | 7 +++----
 .../thread.lock.shared.cons/mutex_defer_lock.pass.cpp      | 7 +++----
 .../thread.lock.shared.cons/mutex_duration.pass.cpp        | 7 +++----
 .../thread.lock.shared.cons/mutex_time_point.pass.cpp      | 7 +++----
 .../thread.lock.shared.cons/mutex_try_to_lock.pass.cpp     | 7 +++----
 .../thread.lock.shared.locking/lock.pass.cpp               | 7 +++----
 .../thread.lock.shared.locking/try_lock.pass.cpp           | 7 +++----
 .../thread.lock.shared.locking/try_lock_for.pass.cpp       | 7 +++----
 .../thread.lock.shared.locking/try_lock_until.pass.cpp     | 7 +++----
 .../thread.lock.shared.locking/unlock.pass.cpp             | 7 +++----
 .../thread.lock.shared.mod/member_swap.pass.cpp            | 7 +++----
 .../thread.lock.shared.mod/nonmember_swap.pass.cpp         | 7 +++----
 .../thread.lock.shared.mod/release.pass.cpp                | 7 +++----
 .../thread.lock.shared.obs/mutex.pass.cpp                  | 7 +++----
 .../thread.lock.shared.obs/op_bool.pass.cpp                | 7 +++----
 .../thread.lock.shared.obs/owns_lock.pass.cpp              | 7 +++----
 .../thread.lock/thread.lock.shared/types.pass.cpp          | 7 +++----
 .../thread.lock.unique.cons/copy_assign.fail.cpp           | 7 +++----
 .../thread.lock.unique.cons/copy_ctor.fail.cpp             | 7 +++----
 .../thread.lock.unique.cons/default.pass.cpp               | 7 +++----
 .../thread.lock.unique.cons/move_assign.pass.cpp           | 7 +++----
 .../thread.lock.unique.cons/move_ctor.pass.cpp             | 7 +++----
 .../thread.lock.unique.cons/mutex.pass.cpp                 | 7 +++----
 .../thread.lock.unique.cons/mutex_adopt_lock.pass.cpp      | 7 +++----
 .../thread.lock.unique.cons/mutex_defer_lock.pass.cpp      | 7 +++----
 .../thread.lock.unique.cons/mutex_duration.pass.cpp        | 7 +++----
 .../thread.lock.unique.cons/mutex_time_point.pass.cpp      | 7 +++----
 .../thread.lock.unique.cons/mutex_try_to_lock.pass.cpp     | 7 +++----
 .../thread.lock.unique.locking/lock.pass.cpp               | 7 +++----
 .../thread.lock.unique.locking/try_lock.pass.cpp           | 7 +++----
 .../thread.lock.unique.locking/try_lock_for.pass.cpp       | 7 +++----
 .../thread.lock.unique.locking/try_lock_until.pass.cpp     | 7 +++----
 .../thread.lock.unique.locking/unlock.pass.cpp             | 7 +++----
 .../thread.lock.unique.mod/member_swap.pass.cpp            | 7 +++----
 .../thread.lock.unique.mod/nonmember_swap.pass.cpp         | 7 +++----
 .../thread.lock.unique.mod/release.pass.cpp                | 7 +++----
 .../thread.lock.unique.obs/mutex.pass.cpp                  | 7 +++----
 .../thread.lock.unique.obs/op_bool.pass.cpp                | 7 +++----
 .../thread.lock.unique.obs/owns_lock.pass.cpp              | 7 +++----
 .../thread.lock/thread.lock.unique/types.pass.cpp          | 7 +++----
 test/std/thread/thread.mutex/thread.lock/types.pass.cpp    | 7 +++----
 .../thread.mutex.requirements/nothing_to_do.pass.cpp       | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../thread.mutex.requirements.mutex/nothing_to_do.pass.cpp | 7 +++----
 .../thread.mutex.class/assign.fail.cpp                     | 7 +++----
 .../thread.mutex.class/copy.fail.cpp                       | 7 +++----
 .../thread.mutex.class/default.pass.cpp                    | 7 +++----
 .../thread.mutex.class/lock.pass.cpp                       | 7 +++----
 .../thread.mutex.class/try_lock.pass.cpp                   | 7 +++----
 .../thread.mutex.recursive/assign.fail.cpp                 | 7 +++----
 .../thread.mutex.recursive/copy.fail.cpp                   | 7 +++----
 .../thread.mutex.recursive/default.pass.cpp                | 7 +++----
 .../thread.mutex.recursive/lock.pass.cpp                   | 7 +++----
 .../thread.mutex.recursive/try_lock.pass.cpp               | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../thread.shared_mutex.class/assign.fail.cpp              | 7 +++----
 .../thread.shared_mutex.class/copy.fail.cpp                | 7 +++----
 .../thread.shared_mutex.class/default.pass.cpp             | 7 +++----
 .../thread.shared_mutex.class/lock.pass.cpp                | 7 +++----
 .../thread.shared_mutex.class/lock_shared.pass.cpp         | 7 +++----
 .../thread.shared_mutex.class/try_lock.pass.cpp            | 7 +++----
 .../thread.shared_mutex.class/try_lock_shared.pass.cpp     | 7 +++----
 .../nothing_to_do.pass.cpp                                 | 7 +++----
 .../thread.sharedtimedmutex.class/assign.fail.cpp          | 7 +++----
 .../thread.sharedtimedmutex.class/copy.fail.cpp            | 7 +++----
 .../thread.sharedtimedmutex.class/default.pass.cpp         | 7 +++----
 .../thread.sharedtimedmutex.class/lock.pass.cpp            | 7 +++----
 .../thread.sharedtimedmutex.class/lock_shared.pass.cpp     | 7 +++----
 .../thread.sharedtimedmutex.class/try_lock.pass.cpp        | 7 +++----
 .../thread.sharedtimedmutex.class/try_lock_for.pass.cpp    | 7 +++----
 .../thread.sharedtimedmutex.class/try_lock_shared.pass.cpp | 7 +++----
 .../try_lock_shared_for.pass.cpp                           | 7 +++----
 .../try_lock_shared_until.pass.cpp                         | 7 +++----
 .../thread.sharedtimedmutex.class/try_lock_until.pass.cpp  | 7 +++----
 .../try_lock_until_deadlock_bug.pass.cpp                   | 7 +++----
 .../thread.timedmutex.requirements/nothing_to_do.pass.cpp  | 7 +++----
 .../thread.timedmutex.class/assign.fail.cpp                | 7 +++----
 .../thread.timedmutex.class/copy.fail.cpp                  | 7 +++----
 .../thread.timedmutex.class/default.pass.cpp               | 7 +++----
 .../thread.timedmutex.class/lock.pass.cpp                  | 7 +++----
 .../thread.timedmutex.class/try_lock.pass.cpp              | 7 +++----
 .../thread.timedmutex.class/try_lock_for.pass.cpp          | 7 +++----
 .../thread.timedmutex.class/try_lock_until.pass.cpp        | 7 +++----
 .../thread.timedmutex.recursive/assign.fail.cpp            | 7 +++----
 .../thread.timedmutex.recursive/copy.fail.cpp              | 7 +++----
 .../thread.timedmutex.recursive/default.pass.cpp           | 7 +++----
 .../thread.timedmutex.recursive/lock.pass.cpp              | 7 +++----
 .../thread.timedmutex.recursive/try_lock.pass.cpp          | 7 +++----
 .../thread.timedmutex.recursive/try_lock_for.pass.cpp      | 7 +++----
 .../thread.timedmutex.recursive/try_lock_until.pass.cpp    | 7 +++----
 .../thread/thread.mutex/thread.once/nothing_to_do.pass.cpp | 7 +++----
 .../thread.once/thread.once.callonce/call_once.pass.cpp    | 7 +++----
 .../thread.once/thread.once.callonce/race.pass.cpp         | 7 +++----
 .../thread.once/thread.once.onceflag/assign.fail.cpp       | 7 +++----
 .../thread.once/thread.once.onceflag/copy.fail.cpp         | 7 +++----
 .../thread.once/thread.once.onceflag/default.pass.cpp      | 7 +++----
 test/std/thread/thread.req/nothing_to_do.pass.cpp          | 7 +++----
 .../thread.req/thread.req.exception/nothing_to_do.pass.cpp | 7 +++----
 .../thread.req/thread.req.lockable/nothing_to_do.pass.cpp  | 7 +++----
 .../thread.req.lockable.basic/nothing_to_do.pass.cpp       | 7 +++----
 .../thread.req.lockable.general/nothing_to_do.pass.cpp     | 7 +++----
 .../thread.req.lockable.req/nothing_to_do.pass.cpp         | 7 +++----
 .../thread.req.lockable.timed/nothing_to_do.pass.cpp       | 7 +++----
 .../thread.req/thread.req.native/nothing_to_do.pass.cpp    | 7 +++----
 .../thread.req/thread.req.paramname/nothing_to_do.pass.cpp | 7 +++----
 .../thread.req/thread.req.timing/nothing_to_do.pass.cpp    | 7 +++----
 .../thread.thread.algorithm/swap.pass.cpp                  | 7 +++----
 .../thread.thread.class/thread.thread.assign/copy.fail.cpp | 7 +++----
 .../thread.thread.class/thread.thread.assign/move.pass.cpp | 7 +++----
 .../thread.thread.assign/move2.pass.cpp                    | 7 +++----
 .../thread.thread.class/thread.thread.constr/F.pass.cpp    | 7 +++----
 .../thread.thread.constr/constr.fail.cpp                   | 7 +++----
 .../thread.thread.class/thread.thread.constr/copy.fail.cpp | 7 +++----
 .../thread.thread.constr/default.pass.cpp                  | 7 +++----
 .../thread.thread.class/thread.thread.constr/move.pass.cpp | 7 +++----
 .../thread.thread.class/thread.thread.destr/dtor.pass.cpp  | 7 +++----
 .../thread.thread.class/thread.thread.id/assign.pass.cpp   | 7 +++----
 .../thread.thread.class/thread.thread.id/copy.pass.cpp     | 7 +++----
 .../thread.thread.class/thread.thread.id/default.pass.cpp  | 7 +++----
 .../thread.thread.id/enabled_hashes.pass.cpp               | 7 +++----
 .../thread.thread.class/thread.thread.id/eq.pass.cpp       | 7 +++----
 .../thread.thread.class/thread.thread.id/lt.pass.cpp       | 7 +++----
 .../thread.thread.class/thread.thread.id/stream.pass.cpp   | 7 +++----
 .../thread.thread.id/thread_id.pass.cpp                    | 7 +++----
 .../thread.thread.member/detach.pass.cpp                   | 7 +++----
 .../thread.thread.member/get_id.pass.cpp                   | 7 +++----
 .../thread.thread.class/thread.thread.member/join.pass.cpp | 7 +++----
 .../thread.thread.member/joinable.pass.cpp                 | 7 +++----
 .../thread.thread.class/thread.thread.member/swap.pass.cpp | 7 +++----
 .../thread.thread.static/hardware_concurrency.pass.cpp     | 7 +++----
 .../thread.threads/thread.thread.this/get_id.pass.cpp      | 7 +++----
 .../thread.thread.this/sleep_for_tested_elsewhere.pass.cpp | 7 +++----
 .../thread.threads/thread.thread.this/sleep_until.pass.cpp | 7 +++----
 .../thread.threads/thread.thread.this/yield.pass.cpp       | 7 +++----
 .../allocator.adaptor.cnstr/allocs.pass.cpp                | 7 +++----
 .../allocator.adaptor.cnstr/converting_copy.pass.cpp       | 7 +++----
 .../allocator.adaptor.cnstr/converting_move.pass.cpp       | 7 +++----
 .../allocator.adaptor.cnstr/copy.pass.cpp                  | 7 +++----
 .../allocator.adaptor.cnstr/default.pass.cpp               | 7 +++----
 .../allocator.adaptor.members/allocate_size.fail.cpp       | 7 +++----
 .../allocator.adaptor.members/allocate_size.pass.cpp       | 7 +++----
 .../allocator.adaptor.members/allocate_size_hint.fail.cpp  | 7 +++----
 .../allocator.adaptor.members/allocate_size_hint.pass.cpp  | 7 +++----
 .../allocator.adaptor.members/construct.pass.cpp           | 7 +++----
 .../allocator.adaptor.members/construct_pair.pass.cpp      | 7 +++----
 .../construct_pair_const_lvalue_pair.pass.cpp              | 7 +++----
 .../construct_pair_piecewise.pass.cpp                      | 7 +++----
 .../construct_pair_rvalue.pass.cpp                         | 7 +++----
 .../construct_pair_values.pass.cpp                         | 7 +++----
 .../allocator.adaptor.members/construct_type.pass.cpp      | 7 +++----
 .../allocator.adaptor.members/deallocate.pass.cpp          | 7 +++----
 .../allocator.adaptor.members/destroy.pass.cpp             | 7 +++----
 .../allocator.adaptor.members/inner_allocator.pass.cpp     | 7 +++----
 .../allocator.adaptor.members/max_size.pass.cpp            | 7 +++----
 .../allocator.adaptor.members/outer_allocator.pass.cpp     | 7 +++----
 .../select_on_container_copy_construction.pass.cpp         | 7 +++----
 .../allocator.adaptor.types/allocator_pointers.pass.cpp    | 7 +++----
 .../allocator.adaptor.types/inner_allocator_type.pass.cpp  | 7 +++----
 .../allocator.adaptor.types/is_always_equal.pass.cpp       | 7 +++----
 .../propagate_on_container_copy_assignment.pass.cpp        | 7 +++----
 .../propagate_on_container_move_assignment.pass.cpp        | 7 +++----
 .../propagate_on_container_swap.pass.cpp                   | 7 +++----
 .../scoped.adaptor.operators/copy_assign.pass.cpp          | 7 +++----
 .../allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp | 7 +++----
 .../scoped.adaptor.operators/move_assign.pass.cpp          | 7 +++----
 test/std/utilities/allocator.adaptor/types.pass.cpp        | 7 +++----
 test/std/utilities/any/any.class/any.assign/copy.pass.cpp  | 7 +++----
 test/std/utilities/any/any.class/any.assign/move.pass.cpp  | 7 +++----
 test/std/utilities/any/any.class/any.assign/value.pass.cpp | 7 +++----
 test/std/utilities/any/any.class/any.cons/copy.pass.cpp    | 7 +++----
 test/std/utilities/any/any.class/any.cons/default.pass.cpp | 7 +++----
 .../any/any.class/any.cons/in_place_type.pass.cpp          | 7 +++----
 test/std/utilities/any/any.class/any.cons/move.pass.cpp    | 7 +++----
 test/std/utilities/any/any.class/any.cons/value.pass.cpp   | 7 +++----
 .../utilities/any/any.class/any.modifiers/emplace.pass.cpp | 7 +++----
 .../utilities/any/any.class/any.modifiers/reset.pass.cpp   | 7 +++----
 .../utilities/any/any.class/any.modifiers/swap.pass.cpp    | 7 +++----
 .../any/any.class/any.observers/has_value.pass.cpp         | 7 +++----
 .../utilities/any/any.class/any.observers/type.pass.cpp    | 7 +++----
 test/std/utilities/any/any.class/not_literal_type.pass.cpp | 7 +++----
 .../any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp  | 7 +++----
 .../any.nonmembers/any.cast/any_cast_reference.pass.cpp    | 7 +++----
 .../any_cast_request_invalid_value_category.fail.cpp       | 7 +++----
 .../any/any.nonmembers/any.cast/const_correctness.fail.cpp | 7 +++----
 .../any.cast/not_copy_constructible.fail.cpp               | 7 +++----
 .../any/any.nonmembers/any.cast/reference_types.fail.cpp   | 7 +++----
 test/std/utilities/any/any.nonmembers/make_any.pass.cpp    | 7 +++----
 test/std/utilities/any/any.nonmembers/swap.pass.cpp        | 7 +++----
 .../charconv/charconv.from.chars/integral.bool.fail.cpp    | 7 +++----
 .../charconv/charconv.from.chars/integral.pass.cpp         | 7 +++----
 .../charconv/charconv.to.chars/integral.bool.fail.cpp      | 7 +++----
 .../utilities/charconv/charconv.to.chars/integral.pass.cpp | 7 +++----
 .../arithmetic.operations/divides.pass.cpp                 | 7 +++----
 .../function.objects/arithmetic.operations/minus.pass.cpp  | 7 +++----
 .../arithmetic.operations/modulus.pass.cpp                 | 7 +++----
 .../arithmetic.operations/multiplies.pass.cpp              | 7 +++----
 .../function.objects/arithmetic.operations/negate.pass.cpp | 7 +++----
 .../function.objects/arithmetic.operations/plus.pass.cpp   | 7 +++----
 .../arithmetic.operations/transparent.pass.cpp             | 7 +++----
 .../func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp   | 7 +++----
 .../func.bind/func.bind.bind/bind_return_type.pass.cpp     | 7 +++----
 .../bind/func.bind/func.bind.bind/copy.pass.cpp            | 7 +++----
 .../func.bind.bind/invoke_function_object.pass.cpp         | 7 +++----
 .../bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp    | 7 +++----
 .../bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp   | 7 +++----
 .../bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp   | 7 +++----
 .../bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp   | 7 +++----
 .../bind/func.bind/func.bind.bind/nested.pass.cpp          | 7 +++----
 .../func.bind/func.bind.isbind/is_bind_expression.pass.cpp | 7 +++----
 .../func.bind.isbind/is_bind_expression_03.pass.cpp        | 7 +++----
 .../func.bind/func.bind.isbind/is_placeholder.pass.cpp     | 7 +++----
 .../bind/func.bind/func.bind.place/placeholders.pass.cpp   | 7 +++----
 .../function.objects/bind/func.bind/nothing_to_do.pass.cpp | 7 +++----
 .../utilities/function.objects/bind/nothing_to_do.pass.cpp | 7 +++----
 .../function.objects/bitwise.operations/bit_and.pass.cpp   | 7 +++----
 .../function.objects/bitwise.operations/bit_not.pass.cpp   | 7 +++----
 .../function.objects/bitwise.operations/bit_or.pass.cpp    | 7 +++----
 .../function.objects/bitwise.operations/bit_xor.pass.cpp   | 7 +++----
 .../bitwise.operations/transparent.pass.cpp                | 7 +++----
 .../function.objects/comparisons/constexpr_init.pass.cpp   | 7 +++----
 .../function.objects/comparisons/equal_to.pass.cpp         | 7 +++----
 .../function.objects/comparisons/greater.pass.cpp          | 7 +++----
 .../function.objects/comparisons/greater_equal.pass.cpp    | 7 +++----
 .../utilities/function.objects/comparisons/less.pass.cpp   | 7 +++----
 .../function.objects/comparisons/less_equal.pass.cpp       | 7 +++----
 .../function.objects/comparisons/not_equal_to.pass.cpp     | 7 +++----
 .../function.objects/comparisons/transparent.pass.cpp      | 7 +++----
 .../function.objects/func.def/nothing_to_do.pass.cpp       | 7 +++----
 .../utilities/function.objects/func.invoke/invoke.pass.cpp | 7 +++----
 .../func.invoke/invoke_feature_test_macro.pass.cpp         | 7 +++----
 .../function.objects/func.memfn/member_data.fail.cpp       | 7 +++----
 .../function.objects/func.memfn/member_data.pass.cpp       | 7 +++----
 .../function.objects/func.memfn/member_function.pass.cpp   | 7 +++----
 .../func.memfn/member_function_const.pass.cpp              | 7 +++----
 .../func.memfn/member_function_const_volatile.pass.cpp     | 7 +++----
 .../func.memfn/member_function_volatile.pass.cpp           | 7 +++----
 .../utilities/function.objects/func.not_fn/not_fn.pass.cpp | 7 +++----
 .../func.require/INVOKE_tested_elsewhere.pass.cpp          | 7 +++----
 .../function.objects/func.require/binary_function.pass.cpp | 7 +++----
 .../function.objects/func.require/unary_function.pass.cpp  | 7 +++----
 .../func.search/func.search.bm/default.pass.cpp            | 7 +++----
 .../func.search/func.search.bm/hash.pass.cpp               | 7 +++----
 .../func.search/func.search.bm/hash.pred.pass.cpp          | 7 +++----
 .../func.search/func.search.bm/pred.pass.cpp               | 7 +++----
 .../func.search/func.search.bmh/default.pass.cpp           | 7 +++----
 .../func.search/func.search.bmh/hash.pass.cpp              | 7 +++----
 .../func.search/func.search.bmh/hash.pred.pass.cpp         | 7 +++----
 .../func.search/func.search.bmh/pred.pass.cpp              | 7 +++----
 .../func.search/func.search.default/default.pass.cpp       | 7 +++----
 .../func.search/func.search.default/default.pred.pass.cpp  | 7 +++----
 .../function.objects/func.search/nothing_to_do.pass.cpp    | 7 +++----
 .../func.wrap/func.wrap.badcall/bad_function_call.pass.cpp | 7 +++----
 .../bad_function_call_ctor.pass.cpp                        | 7 +++----
 .../func.wrap/func.wrap.func/derive_from.fail.cpp          | 7 +++----
 .../func.wrap/func.wrap.func/derive_from.pass.cpp          | 7 +++----
 .../func.wrap.func/func.wrap.func.alg/swap.pass.cpp        | 7 +++----
 .../func.wrap.func.cap/operator_bool.pass.cpp              | 7 +++----
 .../func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp | 7 +++----
 .../func.wrap.func/func.wrap.func.con/F_assign.pass.cpp    | 7 +++----
 .../func.wrap.func.con/F_incomplete.pass.cpp               | 7 +++----
 .../func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp   | 7 +++----
 .../func.wrap.func/func.wrap.func.con/alloc.fail.cpp       | 7 +++----
 .../func.wrap.func/func.wrap.func.con/alloc.pass.cpp       | 7 +++----
 .../func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp     | 7 +++----
 .../func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp     | 7 +++----
 .../func.wrap.func.con/alloc_function.fail.cpp             | 7 +++----
 .../func.wrap.func.con/alloc_function.pass.cpp             | 7 +++----
 .../func.wrap.func.con/alloc_nullptr.fail.cpp              | 7 +++----
 .../func.wrap.func.con/alloc_nullptr.pass.cpp              | 7 +++----
 .../func.wrap.func.con/alloc_rfunction.fail.cpp            | 7 +++----
 .../func.wrap.func.con/alloc_rfunction.pass.cpp            | 7 +++----
 .../func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp | 7 +++----
 .../func.wrap.func/func.wrap.func.con/copy_move.pass.cpp   | 7 +++----
 .../func.wrap.func/func.wrap.func.con/default.pass.cpp     | 7 +++----
 .../func.wrap.func.con/move_reentrant.pass.cpp             | 7 +++----
 .../func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp   | 7 +++----
 .../func.wrap.func.con/nullptr_t_assign.pass.cpp           | 7 +++----
 .../func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp | 7 +++----
 .../func.wrap.func/func.wrap.func.inv/invoke.fail.cpp      | 7 +++----
 .../func.wrap.func/func.wrap.func.inv/invoke.pass.cpp      | 7 +++----
 .../func.wrap.func.mod/assign_F_alloc.pass.cpp             | 7 +++----
 .../func.wrap.func/func.wrap.func.mod/swap.pass.cpp        | 7 +++----
 .../func.wrap.func.nullptr/operator_==.pass.cpp            | 7 +++----
 .../func.wrap.func/func.wrap.func.targ/target.pass.cpp     | 7 +++----
 .../func.wrap.func.targ/target_type.pass.cpp               | 7 +++----
 .../func.wrap/func.wrap.func/function_types.h              | 7 +++----
 .../func.wrap/func.wrap.func/types.pass.cpp                | 7 +++----
 .../function.objects/func.wrap/nothing_to_do.pass.cpp      | 7 +++----
 .../logical.operations/logical_and.pass.cpp                | 7 +++----
 .../logical.operations/logical_not.pass.cpp                | 7 +++----
 .../logical.operations/logical_or.pass.cpp                 | 7 +++----
 .../logical.operations/transparent.pass.cpp                | 7 +++----
 .../negators/binary_negate.depr_in_cxx17.fail.cpp          | 7 +++----
 .../function.objects/negators/binary_negate.pass.cpp       | 7 +++----
 .../function.objects/negators/not1.depr_in_cxx17.fail.cpp  | 7 +++----
 test/std/utilities/function.objects/negators/not1.pass.cpp | 7 +++----
 .../function.objects/negators/not2.depr_in_cxx17.fail.cpp  | 7 +++----
 test/std/utilities/function.objects/negators/not2.pass.cpp | 7 +++----
 .../negators/unary_negate.depr_in_cxx17.fail.cpp           | 7 +++----
 .../function.objects/negators/unary_negate.pass.cpp        | 7 +++----
 .../refwrap/refwrap.access/conversion.pass.cpp             | 7 +++----
 .../refwrap/refwrap.assign/copy_assign.pass.cpp            | 7 +++----
 .../refwrap/refwrap.const/copy_ctor.pass.cpp               | 7 +++----
 .../refwrap/refwrap.const/type_ctor.fail.cpp               | 7 +++----
 .../refwrap/refwrap.const/type_ctor.pass.cpp               | 7 +++----
 .../refwrap/refwrap.helpers/cref_1.pass.cpp                | 7 +++----
 .../refwrap/refwrap.helpers/cref_2.pass.cpp                | 7 +++----
 .../refwrap/refwrap.helpers/ref_1.fail.cpp                 | 7 +++----
 .../refwrap/refwrap.helpers/ref_1.pass.cpp                 | 7 +++----
 .../refwrap/refwrap.helpers/ref_2.pass.cpp                 | 7 +++----
 .../refwrap/refwrap.invoke/invoke.fail.cpp                 | 7 +++----
 .../refwrap/refwrap.invoke/invoke.pass.cpp                 | 7 +++----
 .../refwrap/refwrap.invoke/invoke_int_0.pass.cpp           | 7 +++----
 .../refwrap/refwrap.invoke/invoke_void_0.pass.cpp          | 7 +++----
 test/std/utilities/function.objects/refwrap/type.pass.cpp  | 7 +++----
 .../function.objects/refwrap/type_properties.pass.cpp      | 7 +++----
 .../function.objects/refwrap/unwrap_ref_decay.pass.cpp     | 7 +++----
 .../function.objects/refwrap/unwrap_reference.pass.cpp     | 7 +++----
 .../function.objects/refwrap/weak_result.pass.cpp          | 7 +++----
 .../function.objects/unord.hash/enabled_hashes.pass.cpp    | 7 +++----
 .../utilities/function.objects/unord.hash/enum.fail.cpp    | 7 +++----
 .../utilities/function.objects/unord.hash/enum.pass.cpp    | 7 +++----
 .../function.objects/unord.hash/floating.pass.cpp          | 7 +++----
 .../function.objects/unord.hash/integral.pass.cpp          | 7 +++----
 .../function.objects/unord.hash/non_enum.pass.cpp          | 7 +++----
 .../utilities/function.objects/unord.hash/pointer.pass.cpp | 7 +++----
 .../utilities/intseq/intseq.general/integer_seq.pass.cpp   | 7 +++----
 .../utilities/intseq/intseq.intseq/integer_seq.fail.cpp    | 7 +++----
 .../utilities/intseq/intseq.intseq/integer_seq.pass.cpp    | 7 +++----
 .../utilities/intseq/intseq.make/make_integer_seq.fail.cpp | 7 +++----
 .../utilities/intseq/intseq.make/make_integer_seq.pass.cpp | 7 +++----
 .../intseq/intseq.make/make_integer_seq_fallback.fail.cpp  | 7 +++----
 .../intseq/intseq.make/make_integer_seq_fallback.pass.cpp  | 7 +++----
 test/std/utilities/intseq/nothing_to_do.pass.cpp           | 7 +++----
 .../utilities/memory/allocator.tag/allocator_arg.pass.cpp  | 7 +++----
 .../allocator.traits.members/allocate.fail.cpp             | 7 +++----
 .../allocator.traits.members/allocate.pass.cpp             | 7 +++----
 .../allocator.traits.members/allocate_hint.pass.cpp        | 7 +++----
 .../allocator.traits.members/construct.pass.cpp            | 7 +++----
 .../allocator.traits.members/deallocate.pass.cpp           | 7 +++----
 .../allocator.traits.members/destroy.pass.cpp              | 7 +++----
 .../allocator.traits.members/max_size.pass.cpp             | 7 +++----
 .../select_on_container_copy_construction.pass.cpp         | 7 +++----
 .../allocator.traits.types/const_pointer.pass.cpp          | 7 +++----
 .../allocator.traits.types/const_void_pointer.pass.cpp     | 7 +++----
 .../allocator.traits.types/difference_type.pass.cpp        | 7 +++----
 .../allocator.traits.types/is_always_equal.pass.cpp        | 7 +++----
 .../allocator.traits.types/pointer.pass.cpp                | 7 +++----
 .../propagate_on_container_copy_assignment.pass.cpp        | 7 +++----
 .../propagate_on_container_move_assignment.pass.cpp        | 7 +++----
 .../propagate_on_container_swap.pass.cpp                   | 7 +++----
 .../allocator.traits.types/rebind_alloc.pass.cpp           | 7 +++----
 .../allocator.traits.types/size_type.pass.cpp              | 7 +++----
 .../allocator.traits.types/void_pointer.pass.cpp           | 7 +++----
 .../memory/allocator.traits/allocator_type.pass.cpp        | 7 +++----
 .../memory/allocator.traits/rebind_traits.pass.cpp         | 7 +++----
 .../utilities/memory/allocator.traits/value_type.pass.cpp  | 7 +++----
 .../allocator.uses.construction/tested_elsewhere.pass.cpp  | 7 +++----
 .../allocator.uses.trait/uses_allocator.pass.cpp           | 7 +++----
 .../utilities/memory/allocator.uses/nothing_to_do.pass.cpp | 7 +++----
 test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp  | 7 +++----
 .../memory/default.allocator/allocator.ctor.pass.cpp       | 7 +++----
 .../memory/default.allocator/allocator.globals/eq.pass.cpp | 7 +++----
 .../default.allocator/allocator.members/address.pass.cpp   | 7 +++----
 .../default.allocator/allocator.members/allocate.fail.cpp  | 7 +++----
 .../default.allocator/allocator.members/allocate.pass.cpp  | 7 +++----
 .../allocator.members/allocate.size.pass.cpp               | 7 +++----
 .../default.allocator/allocator.members/construct.pass.cpp | 7 +++----
 .../default.allocator/allocator.members/max_size.pass.cpp  | 7 +++----
 .../memory/default.allocator/allocator_pointers.pass.cpp   | 7 +++----
 .../memory/default.allocator/allocator_types.pass.cpp      | 7 +++----
 .../memory/default.allocator/allocator_void.pass.cpp       | 7 +++----
 .../memory/pointer.conversion/to_address.pass.cpp          | 7 +++----
 .../memory/pointer.traits/difference_type.pass.cpp         | 7 +++----
 .../utilities/memory/pointer.traits/element_type.pass.cpp  | 7 +++----
 test/std/utilities/memory/pointer.traits/pointer.pass.cpp  | 7 +++----
 .../pointer.traits.functions/pointer_to.pass.cpp           | 7 +++----
 .../pointer.traits.types/difference_type.pass.cpp          | 7 +++----
 .../pointer.traits.types/element_type.pass.cpp             | 7 +++----
 .../pointer.traits/pointer.traits.types/rebind.pass.cpp    | 7 +++----
 .../utilities/memory/pointer.traits/pointer_to.pass.cpp    | 7 +++----
 test/std/utilities/memory/pointer.traits/rebind.pass.cpp   | 7 +++----
 test/std/utilities/memory/ptr.align/align.pass.cpp         | 7 +++----
 .../memory/specialized.algorithms/nothing_to_do.pass.cpp   | 7 +++----
 .../specialized.addressof/addressof.pass.cpp               | 7 +++----
 .../specialized.addressof/addressof.temp.fail.cpp          | 7 +++----
 .../specialized.addressof/constexpr_addressof.pass.cpp     | 7 +++----
 .../specialized.destroy/destroy.pass.cpp                   | 7 +++----
 .../specialized.destroy/destroy_at.pass.cpp                | 7 +++----
 .../specialized.destroy/destroy_n.pass.cpp                 | 7 +++----
 .../uninitialized_default_construct.pass.cpp               | 7 +++----
 .../uninitialized_default_construct_n.pass.cpp             | 7 +++----
 .../uninitialized_value_construct.pass.cpp                 | 7 +++----
 .../uninitialized_value_construct_n.pass.cpp               | 7 +++----
 .../uninitialized.copy/uninitialized_copy.pass.cpp         | 7 +++----
 .../uninitialized.copy/uninitialized_copy_n.pass.cpp       | 7 +++----
 .../uninitialized.fill.n/uninitialized_fill_n.pass.cpp     | 7 +++----
 .../uninitialized.fill/uninitialized_fill.pass.cpp         | 7 +++----
 .../uninitialized.move/uninitialized_move.pass.cpp         | 7 +++----
 .../uninitialized.move/uninitialized_move_n.pass.cpp       | 7 +++----
 .../storage.iterator/raw_storage_iterator.base.pass.cpp    | 7 +++----
 .../memory/storage.iterator/raw_storage_iterator.pass.cpp  | 7 +++----
 .../utilities/memory/temporary.buffer/overaligned.pass.cpp | 7 +++----
 .../memory/temporary.buffer/temporary_buffer.pass.cpp      | 7 +++----
 .../memory/unique.ptr/unique.ptr.special/io.fail.cpp       | 7 +++----
 .../memory/unique.ptr/unique.ptr.special/io.pass.cpp       | 7 +++----
 .../util.dynamic.safety/declare_no_pointers.pass.cpp       | 7 +++----
 .../memory/util.dynamic.safety/declare_reachable.pass.cpp  | 7 +++----
 .../memory/util.dynamic.safety/get_pointer_safety.pass.cpp | 7 +++----
 .../utilities/memory/util.smartptr/nothing_to_do.pass.cpp  | 7 +++----
 .../util.smartptr.enab/enable_shared_from_this.pass.cpp    | 7 +++----
 .../util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp | 7 +++----
 .../util.smartptr.hash/hash_shared_ptr.pass.cpp            | 7 +++----
 .../util.smartptr.hash/hash_unique_ptr.pass.cpp            | 7 +++----
 .../atomic_compare_exchange_strong.pass.cpp                | 7 +++----
 .../atomic_compare_exchange_strong_explicit.pass.cpp       | 7 +++----
 .../atomic_compare_exchange_weak.pass.cpp                  | 7 +++----
 .../atomic_compare_exchange_weak_explicit.pass.cpp         | 7 +++----
 .../util.smartptr.shared.atomic/atomic_exchange.pass.cpp   | 7 +++----
 .../atomic_exchange_explicit.pass.cpp                      | 7 +++----
 .../atomic_is_lock_free.pass.cpp                           | 7 +++----
 .../util.smartptr.shared.atomic/atomic_load.pass.cpp       | 7 +++----
 .../atomic_load_explicit.pass.cpp                          | 7 +++----
 .../util.smartptr.shared.atomic/atomic_store.pass.cpp      | 7 +++----
 .../atomic_store_explicit.pass.cpp                         | 7 +++----
 .../util.smartptr/util.smartptr.shared/types.pass.cpp      | 7 +++----
 .../util.smartptr.getdeleter/get_deleter.pass.cpp          | 7 +++----
 .../util.smartptr.shared.assign/auto_ptr_Y.pass.cpp        | 7 +++----
 .../util.smartptr.shared.assign/shared_ptr.pass.cpp        | 7 +++----
 .../util.smartptr.shared.assign/shared_ptr_Y.pass.cpp      | 7 +++----
 .../util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp   | 7 +++----
 .../util.smartptr.shared.assign/shared_ptr_rv.pass.cpp     | 7 +++----
 .../util.smartptr.shared.assign/unique_ptr_Y.pass.cpp      | 7 +++----
 .../util.smartptr.shared.cast/const_pointer_cast.pass.cpp  | 7 +++----
 .../dynamic_pointer_cast.pass.cpp                          | 7 +++----
 .../util.smartptr.shared.cast/static_pointer_cast.pass.cpp | 7 +++----
 .../util.smartptr.shared.cmp/cmp_nullptr.pass.cpp          | 7 +++----
 .../util.smartptr.shared.cmp/eq.pass.cpp                   | 7 +++----
 .../util.smartptr.shared.cmp/lt.pass.cpp                   | 7 +++----
 .../util.smartptr.shared.const/auto_ptr.pass.cpp           | 7 +++----
 .../util.smartptr.shared.const/default.pass.cpp            | 7 +++----
 .../util.smartptr.shared.const/nullptr_t.pass.cpp          | 7 +++----
 .../util.smartptr.shared.const/nullptr_t_deleter.pass.cpp  | 7 +++----
 .../nullptr_t_deleter_allocator.pass.cpp                   | 7 +++----
 .../nullptr_t_deleter_allocator_throw.pass.cpp             | 7 +++----
 .../nullptr_t_deleter_throw.pass.cpp                       | 7 +++----
 .../util.smartptr.shared.const/pointer.pass.cpp            | 7 +++----
 .../util.smartptr.shared.const/pointer_deleter.pass.cpp    | 7 +++----
 .../pointer_deleter_allocator.pass.cpp                     | 7 +++----
 .../pointer_deleter_allocator_throw.pass.cpp               | 7 +++----
 .../pointer_deleter_throw.pass.cpp                         | 7 +++----
 .../util.smartptr.shared.const/pointer_throw.pass.cpp      | 7 +++----
 .../util.smartptr.shared.const/shared_ptr.pass.cpp         | 7 +++----
 .../util.smartptr.shared.const/shared_ptr_Y.pass.cpp       | 7 +++----
 .../util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp    | 7 +++----
 .../util.smartptr.shared.const/shared_ptr_pointer.pass.cpp | 7 +++----
 .../util.smartptr.shared.const/shared_ptr_rv.pass.cpp      | 7 +++----
 .../util.smartptr.shared.const/unique_ptr.pass.cpp         | 7 +++----
 .../util.smartptr.shared.const/weak_ptr.pass.cpp           | 7 +++----
 .../util.smartptr.shared.create/allocate_shared.pass.cpp   | 7 +++----
 .../allocate_shared_cxx03.pass.cpp                         | 7 +++----
 .../util.smartptr.shared.create/make_shared.pass.cpp       | 7 +++----
 .../make_shared.private.fail.cpp                           | 7 +++----
 .../make_shared.protected.fail.cpp                         | 7 +++----
 .../make_shared.volatile.pass.cpp                          | 7 +++----
 .../util.smartptr.shared.dest/tested_elsewhere.pass.cpp    | 7 +++----
 .../util.smartptr.shared.io/io.pass.cpp                    | 7 +++----
 .../util.smartptr.shared.mod/reset.pass.cpp                | 7 +++----
 .../util.smartptr.shared.mod/reset_pointer.pass.cpp        | 7 +++----
 .../reset_pointer_deleter.pass.cpp                         | 7 +++----
 .../reset_pointer_deleter_allocator.pass.cpp               | 7 +++----
 .../util.smartptr.shared.mod/swap.pass.cpp                 | 7 +++----
 .../util.smartptr.shared.obs/arrow.pass.cpp                | 7 +++----
 .../util.smartptr.shared.obs/dereference.pass.cpp          | 7 +++----
 .../util.smartptr.shared.obs/op_bool.pass.cpp              | 7 +++----
 .../owner_before_shared_ptr.pass.cpp                       | 7 +++----
 .../owner_before_weak_ptr.pass.cpp                         | 7 +++----
 .../util.smartptr.shared.obs/unique.pass.cpp               | 7 +++----
 .../memory/util.smartptr/util.smartptr.weak/types.pass.cpp | 7 +++----
 .../util.smartptr.ownerless/owner_less.pass.cpp            | 7 +++----
 .../util.smartptr.weak.assign/shared_ptr_Y.pass.cpp        | 7 +++----
 .../util.smartptr.weak.assign/weak_ptr.pass.cpp            | 7 +++----
 .../util.smartptr.weak.assign/weak_ptr_Y.pass.cpp          | 7 +++----
 .../util.smartptr.weak.const/default.pass.cpp              | 7 +++----
 .../util.smartptr.weak.const/shared_ptr_Y.pass.cpp         | 7 +++----
 .../util.smartptr.weak.const/weak_ptr.pass.cpp             | 7 +++----
 .../util.smartptr.weak.const/weak_ptr_Y.pass.cpp           | 7 +++----
 .../util.smartptr.weak.dest/tested_elsewhere.pass.cpp      | 7 +++----
 .../util.smartptr.weak.mod/reset.pass.cpp                  | 7 +++----
 .../util.smartptr.weak.mod/swap.pass.cpp                   | 7 +++----
 .../util.smartptr.weak.obs/expired.pass.cpp                | 7 +++----
 .../util.smartptr.weak.obs/lock.pass.cpp                   | 7 +++----
 .../util.smartptr.weak.obs/not_less_than.fail.cpp          | 7 +++----
 .../owner_before_shared_ptr.pass.cpp                       | 7 +++----
 .../util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp  | 7 +++----
 .../util.smartptr.weakptr/bad_weak_ptr.pass.cpp            | 7 +++----
 test/std/utilities/meta/meta.help/bool_constant.pass.cpp   | 7 +++----
 .../utilities/meta/meta.help/integral_constant.pass.cpp    | 7 +++----
 test/std/utilities/meta/meta.logical/conjunction.pass.cpp  | 7 +++----
 test/std/utilities/meta/meta.logical/disjunction.pass.cpp  | 7 +++----
 test/std/utilities/meta/meta.logical/negation.pass.cpp     | 7 +++----
 test/std/utilities/meta/meta.rel/is_base_of.pass.cpp       | 7 +++----
 test/std/utilities/meta/meta.rel/is_convertible.pass.cpp   | 7 +++----
 .../meta/meta.rel/is_convertible_fallback.pass.cpp         | 7 +++----
 test/std/utilities/meta/meta.rel/is_invocable.pass.cpp     | 7 +++----
 .../utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp  | 7 +++----
 test/std/utilities/meta/meta.rel/is_same.pass.cpp          | 7 +++----
 test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp  | 7 +++----
 .../meta.trans/meta.trans.arr/remove_all_extents.pass.cpp  | 7 +++----
 .../meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp  | 7 +++----
 .../meta/meta.trans/meta.trans.cv/add_const.pass.cpp       | 7 +++----
 .../meta/meta.trans/meta.trans.cv/add_cv.pass.cpp          | 7 +++----
 .../meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp    | 7 +++----
 .../meta/meta.trans/meta.trans.cv/remove_const.pass.cpp    | 7 +++----
 .../meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp       | 7 +++----
 .../meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp | 7 +++----
 .../meta.trans/meta.trans.other/aligned_storage.pass.cpp   | 7 +++----
 .../meta.trans/meta.trans.other/aligned_union.fail.cpp     | 7 +++----
 .../meta.trans/meta.trans.other/aligned_union.pass.cpp     | 7 +++----
 .../meta/meta.trans/meta.trans.other/common_type.pass.cpp  | 7 +++----
 .../meta/meta.trans/meta.trans.other/conditional.pass.cpp  | 7 +++----
 .../meta/meta.trans/meta.trans.other/decay.pass.cpp        | 7 +++----
 .../meta/meta.trans/meta.trans.other/enable_if.fail.cpp    | 7 +++----
 .../meta/meta.trans/meta.trans.other/enable_if.pass.cpp    | 7 +++----
 .../meta/meta.trans/meta.trans.other/enable_if2.fail.cpp   | 7 +++----
 .../meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp | 7 +++----
 .../meta/meta.trans/meta.trans.other/result_of.pass.cpp    | 7 +++----
 .../meta/meta.trans/meta.trans.other/result_of11.pass.cpp  | 7 +++----
 .../meta.trans/meta.trans.other/type_identity.pass.cpp     | 7 +++----
 .../meta.trans/meta.trans.other/underlying_type.pass.cpp   | 7 +++----
 .../meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp    | 7 +++----
 .../meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp | 7 +++----
 .../meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp | 7 +++----
 .../meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp | 7 +++----
 .../meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp     | 7 +++----
 .../meta/meta.trans/meta.trans.sign/make_signed.pass.cpp   | 7 +++----
 .../meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp | 7 +++----
 test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp  | 7 +++----
 test/std/utilities/meta/meta.type.synop/endian.pass.cpp    | 7 +++----
 .../utilities/meta/meta.type.synop/nothing_to_do.pass.cpp  | 7 +++----
 .../meta/meta.unary.prop.query/alignment_of.pass.cpp       | 7 +++----
 .../utilities/meta/meta.unary.prop.query/extent.pass.cpp   | 7 +++----
 .../std/utilities/meta/meta.unary.prop.query/rank.pass.cpp | 7 +++----
 .../utilities/meta/meta.unary.prop.query/void_t.pass.cpp   | 7 +++----
 .../void_t_feature_test_macro.pass.cpp                     | 7 +++----
 .../meta/meta.unary/meta.unary.cat/array.pass.cpp          | 7 +++----
 .../meta/meta.unary/meta.unary.cat/class.pass.cpp          | 7 +++----
 .../utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp | 7 +++----
 .../meta/meta.unary/meta.unary.cat/floating_point.pass.cpp | 7 +++----
 .../meta/meta.unary/meta.unary.cat/function.pass.cpp       | 7 +++----
 .../meta/meta.unary/meta.unary.cat/integral.pass.cpp       | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_array.pass.cpp       | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_class.pass.cpp       | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_enum.pass.cpp        | 7 +++----
 .../meta.unary/meta.unary.cat/is_floating_point.pass.cpp   | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_function.pass.cpp    | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_integral.pass.cpp    | 7 +++----
 .../meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp | 7 +++----
 .../meta.unary.cat/is_member_object_pointer.pass.cpp       | 7 +++----
 .../meta.unary/meta.unary.cat/is_member_pointer.pass.cpp   | 7 +++----
 .../meta.unary/meta.unary.cat/is_null_pointer.pass.cpp     | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp     | 7 +++----
 .../meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_union.pass.cpp       | 7 +++----
 .../meta/meta.unary/meta.unary.cat/is_void.pass.cpp        | 7 +++----
 .../meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp     | 7 +++----
 .../meta.unary.cat/member_function_pointer.pass.cpp        | 7 +++----
 .../member_function_pointer_no_variadics.pass.cpp          | 7 +++----
 .../meta.unary.cat/member_object_pointer.pass.cpp          | 7 +++----
 .../meta/meta.unary/meta.unary.cat/nullptr.pass.cpp        | 7 +++----
 .../meta/meta.unary/meta.unary.cat/pointer.pass.cpp        | 7 +++----
 .../meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp     | 7 +++----
 .../meta/meta.unary/meta.unary.cat/union.pass.cpp          | 7 +++----
 .../utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp | 7 +++----
 .../meta/meta.unary/meta.unary.comp/array.pass.cpp         | 7 +++----
 .../meta/meta.unary/meta.unary.comp/class.pass.cpp         | 7 +++----
 .../meta/meta.unary/meta.unary.comp/enum.pass.cpp          | 7 +++----
 .../meta.unary/meta.unary.comp/floating_point.pass.cpp     | 7 +++----
 .../meta/meta.unary/meta.unary.comp/function.pass.cpp      | 7 +++----
 .../meta/meta.unary/meta.unary.comp/integral.pass.cpp      | 7 +++----
 .../meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp | 7 +++----
 .../meta/meta.unary/meta.unary.comp/is_compound.pass.cpp   | 7 +++----
 .../meta.unary/meta.unary.comp/is_fundamental.pass.cpp     | 7 +++----
 .../meta.unary/meta.unary.comp/is_member_pointer.pass.cpp  | 7 +++----
 .../meta/meta.unary/meta.unary.comp/is_object.pass.cpp     | 7 +++----
 .../meta/meta.unary/meta.unary.comp/is_reference.pass.cpp  | 7 +++----
 .../meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp     | 7 +++----
 .../meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp    | 7 +++----
 .../meta.unary.comp/member_function_pointer.pass.cpp       | 7 +++----
 .../meta.unary.comp/member_object_pointer.pass.cpp         | 7 +++----
 .../meta/meta.unary/meta.unary.comp/pointer.pass.cpp       | 7 +++----
 .../meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp    | 7 +++----
 .../meta/meta.unary/meta.unary.comp/union.pass.cpp         | 7 +++----
 .../meta/meta.unary/meta.unary.comp/void.pass.cpp          | 7 +++----
 .../has_unique_object_representations.pass.cpp             | 7 +++----
 .../meta.unary.prop/has_virtual_destructor.pass.cpp        | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp   | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp  | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_const.pass.cpp      | 7 +++----
 .../meta.unary/meta.unary.prop/is_constructible.pass.cpp   | 7 +++----
 .../meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp | 7 +++----
 .../meta.unary.prop/is_copy_constructible.pass.cpp         | 7 +++----
 .../meta.unary.prop/is_default_constructible.pass.cpp      | 7 +++----
 .../meta.unary/meta.unary.prop/is_destructible.pass.cpp    | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_empty.pass.cpp      | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_final.pass.cpp      | 7 +++----
 .../meta.unary/meta.unary.prop/is_literal_type.pass.cpp    | 7 +++----
 .../meta.unary/meta.unary.prop/is_move_assignable.pass.cpp | 7 +++----
 .../meta.unary.prop/is_move_constructible.pass.cpp         | 7 +++----
 .../meta.unary.prop/is_nothrow_assignable.pass.cpp         | 7 +++----
 .../meta.unary.prop/is_nothrow_constructible.pass.cpp      | 7 +++----
 .../meta.unary.prop/is_nothrow_copy_assignable.pass.cpp    | 7 +++----
 .../meta.unary.prop/is_nothrow_copy_constructible.pass.cpp | 7 +++----
 .../is_nothrow_default_constructible.pass.cpp              | 7 +++----
 .../meta.unary.prop/is_nothrow_destructible.pass.cpp       | 7 +++----
 .../meta.unary.prop/is_nothrow_move_assignable.pass.cpp    | 7 +++----
 .../meta.unary.prop/is_nothrow_move_constructible.pass.cpp | 7 +++----
 .../meta.unary.prop/is_nothrow_swappable.pass.cpp          | 7 +++----
 .../meta.unary.prop/is_nothrow_swappable_with.pass.cpp     | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_pod.pass.cpp        | 7 +++----
 .../meta.unary/meta.unary.prop/is_polymorphic.pass.cpp     | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_signed.pass.cpp     | 7 +++----
 .../meta.unary/meta.unary.prop/is_standard_layout.pass.cpp | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp  | 7 +++----
 .../meta.unary.prop/is_swappable_include_order.pass.cpp    | 7 +++----
 .../meta.unary/meta.unary.prop/is_swappable_with.pass.cpp  | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp    | 7 +++----
 .../meta.unary.prop/is_trivially_assignable.pass.cpp       | 7 +++----
 .../meta.unary.prop/is_trivially_constructible.pass.cpp    | 7 +++----
 .../meta.unary.prop/is_trivially_copy_assignable.pass.cpp  | 7 +++----
 .../is_trivially_copy_constructible.pass.cpp               | 7 +++----
 .../meta.unary.prop/is_trivially_copyable.pass.cpp         | 7 +++----
 .../is_trivially_default_constructible.pass.cpp            | 7 +++----
 .../meta.unary.prop/is_trivially_destructible.pass.cpp     | 7 +++----
 .../meta.unary.prop/is_trivially_move_assignable.pass.cpp  | 7 +++----
 .../is_trivially_move_constructible.pass.cpp               | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp   | 7 +++----
 .../meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp   | 7 +++----
 test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp  | 7 +++----
 test/std/utilities/nothing_to_do.pass.cpp                  | 7 +++----
 .../optional/optional.bad_optional_access/default.pass.cpp | 7 +++----
 .../optional/optional.bad_optional_access/derive.pass.cpp  | 7 +++----
 .../utilities/optional/optional.comp_with_t/equal.pass.cpp | 7 +++----
 .../optional/optional.comp_with_t/greater.pass.cpp         | 7 +++----
 .../optional/optional.comp_with_t/greater_equal.pass.cpp   | 7 +++----
 .../optional/optional.comp_with_t/less_equal.pass.cpp      | 7 +++----
 .../optional/optional.comp_with_t/less_than.pass.cpp       | 7 +++----
 .../optional/optional.comp_with_t/not_equal.pass.cpp       | 7 +++----
 .../utilities/optional/optional.hash/enabled_hash.pass.cpp | 7 +++----
 test/std/utilities/optional/optional.hash/hash.pass.cpp    | 7 +++----
 .../std/utilities/optional/optional.nullops/equal.pass.cpp | 7 +++----
 .../utilities/optional/optional.nullops/greater.pass.cpp   | 7 +++----
 .../optional/optional.nullops/greater_equal.pass.cpp       | 7 +++----
 .../optional/optional.nullops/less_equal.pass.cpp          | 7 +++----
 .../utilities/optional/optional.nullops/less_than.pass.cpp | 7 +++----
 .../utilities/optional/optional.nullops/not_equal.pass.cpp | 7 +++----
 .../utilities/optional/optional.nullopt/nullopt_t.fail.cpp | 7 +++----
 .../utilities/optional/optional.nullopt/nullopt_t.pass.cpp | 7 +++----
 .../optional.object.assign/assign_value.pass.cpp           | 7 +++----
 .../optional.object.assign/const_optional_U.pass.cpp       | 7 +++----
 .../optional.object/optional.object.assign/copy.pass.cpp   | 7 +++----
 .../optional.object.assign/emplace.pass.cpp                | 7 +++----
 .../emplace_initializer_list.pass.cpp                      | 7 +++----
 .../optional.object/optional.object.assign/move.pass.cpp   | 7 +++----
 .../optional.object.assign/nullopt_t.pass.cpp              | 7 +++----
 .../optional.object.assign/optional_U.pass.cpp             | 7 +++----
 .../optional.object/optional.object.ctor/U.pass.cpp        | 7 +++----
 .../optional.object/optional.object.ctor/const_T.pass.cpp  | 7 +++----
 .../optional.object.ctor/const_optional_U.pass.cpp         | 7 +++----
 .../optional.object/optional.object.ctor/copy.pass.cpp     | 7 +++----
 .../optional.object/optional.object.ctor/deduct.fail.cpp   | 7 +++----
 .../optional.object/optional.object.ctor/deduct.pass.cpp   | 7 +++----
 .../optional.object/optional.object.ctor/default.pass.cpp  | 7 +++----
 .../explicit_const_optional_U.pass.cpp                     | 7 +++----
 .../optional.object.ctor/explicit_optional_U.pass.cpp      | 7 +++----
 .../optional.object.ctor/in_place_t.pass.cpp               | 7 +++----
 .../optional.object.ctor/initializer_list.pass.cpp         | 7 +++----
 .../optional.object/optional.object.ctor/move.fail.cpp     | 7 +++----
 .../optional.object/optional.object.ctor/move.pass.cpp     | 7 +++----
 .../optional.object.ctor/nullopt_t.pass.cpp                | 7 +++----
 .../optional.object.ctor/optional_U.pass.cpp               | 7 +++----
 .../optional.object/optional.object.ctor/rvalue_T.pass.cpp | 7 +++----
 .../optional.object/optional.object.dtor/dtor.pass.cpp     | 7 +++----
 .../optional.object/optional.object.mod/reset.pass.cpp     | 7 +++----
 .../optional.object/optional.object.observe/bool.pass.cpp  | 7 +++----
 .../optional.object.observe/dereference.pass.cpp           | 7 +++----
 .../optional.object.observe/dereference_const.pass.cpp     | 7 +++----
 .../dereference_const_rvalue.pass.cpp                      | 7 +++----
 .../optional.object.observe/dereference_rvalue.pass.cpp    | 7 +++----
 .../optional.object.observe/has_value.pass.cpp             | 7 +++----
 .../optional.object.observe/op_arrow.pass.cpp              | 7 +++----
 .../optional.object.observe/op_arrow_const.pass.cpp        | 7 +++----
 .../optional.object/optional.object.observe/value.pass.cpp | 7 +++----
 .../optional.object.observe/value_const.fail.cpp           | 7 +++----
 .../optional.object.observe/value_const.pass.cpp           | 7 +++----
 .../optional.object.observe/value_const_rvalue.pass.cpp    | 7 +++----
 .../optional.object.observe/value_or.pass.cpp              | 7 +++----
 .../optional.object.observe/value_or_const.pass.cpp        | 7 +++----
 .../optional.object.observe/value_rvalue.pass.cpp          | 7 +++----
 .../optional.object/optional.object.swap/swap.pass.cpp     | 7 +++----
 .../optional_requires_destructible_object.fail.cpp         | 7 +++----
 .../optional/optional.object/special_members.pass.cpp      | 7 +++----
 .../utilities/optional/optional.object/triviality.pass.cpp | 7 +++----
 test/std/utilities/optional/optional.object/types.pass.cpp | 7 +++----
 test/std/utilities/optional/optional.relops/equal.pass.cpp | 7 +++----
 .../optional/optional.relops/greater_equal.pass.cpp        | 7 +++----
 .../optional/optional.relops/greater_than.pass.cpp         | 7 +++----
 .../utilities/optional/optional.relops/less_equal.pass.cpp | 7 +++----
 .../utilities/optional/optional.relops/less_than.pass.cpp  | 7 +++----
 .../utilities/optional/optional.relops/not_equal.pass.cpp  | 7 +++----
 .../optional/optional.specalg/make_optional.pass.cpp       | 7 +++----
 .../optional.specalg/make_optional_explicit.pass.cpp       | 7 +++----
 .../make_optional_explicit_initializer_list.pass.cpp       | 7 +++----
 test/std/utilities/optional/optional.specalg/swap.pass.cpp | 7 +++----
 .../optional/optional.syn/optional_in_place_t.fail.cpp     | 7 +++----
 .../optional_includes_initializer_list.pass.cpp            | 7 +++----
 .../optional/optional.syn/optional_nullopt_t.fail.cpp      | 7 +++----
 .../utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp    | 7 +++----
 .../utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp    | 7 +++----
 .../utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp | 7 +++----
 .../utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp | 7 +++----
 .../ratio/ratio.arithmetic/ratio_multiply.fail.cpp         | 7 +++----
 .../ratio/ratio.arithmetic/ratio_multiply.pass.cpp         | 7 +++----
 .../ratio/ratio.arithmetic/ratio_subtract.fail.cpp         | 7 +++----
 .../ratio/ratio.arithmetic/ratio_subtract.pass.cpp         | 7 +++----
 .../utilities/ratio/ratio.comparison/ratio_equal.pass.cpp  | 7 +++----
 .../ratio/ratio.comparison/ratio_greater.pass.cpp          | 7 +++----
 .../ratio/ratio.comparison/ratio_greater_equal.pass.cpp    | 7 +++----
 .../utilities/ratio/ratio.comparison/ratio_less.pass.cpp   | 7 +++----
 .../ratio/ratio.comparison/ratio_less_equal.pass.cpp       | 7 +++----
 .../ratio/ratio.comparison/ratio_not_equal.pass.cpp        | 7 +++----
 test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp        | 7 +++----
 test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp       | 7 +++----
 test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp       | 7 +++----
 test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp       | 7 +++----
 test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp   | 7 +++----
 test/std/utilities/ratio/typedefs.pass.cpp                 | 7 +++----
 .../utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp   | 7 +++----
 .../unique.ptr/unique.ptr.class/pointer_type.pass.cpp      | 7 +++----
 .../unique.ptr.class/unique.ptr.asgn/move.pass.cpp         | 7 +++----
 .../unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp | 7 +++----
 .../unique.ptr.asgn/move_convert.runtime.pass.cpp          | 7 +++----
 .../unique.ptr.asgn/move_convert.single.pass.cpp           | 7 +++----
 .../unique.ptr.class/unique.ptr.asgn/null.pass.cpp         | 7 +++----
 .../unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp      | 7 +++----
 .../unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp | 7 +++----
 .../unique.ptr.class/unique.ptr.ctor/default.pass.cpp      | 7 +++----
 .../unique.ptr.class/unique.ptr.ctor/move.pass.cpp         | 7 +++----
 .../unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp | 7 +++----
 .../unique.ptr.ctor/move_convert.runtime.pass.cpp          | 7 +++----
 .../unique.ptr.ctor/move_convert.single.pass.cpp           | 7 +++----
 .../unique.ptr.class/unique.ptr.ctor/null.pass.cpp         | 7 +++----
 .../unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp      | 7 +++----
 .../unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp      | 7 +++----
 .../unique.ptr.ctor/pointer_deleter.fail.cpp               | 7 +++----
 .../unique.ptr.ctor/pointer_deleter.pass.cpp               | 7 +++----
 .../unique.ptr.class/unique.ptr.dtor/null.pass.cpp         | 7 +++----
 .../unique.ptr.class/unique.ptr.modifiers/release.pass.cpp | 7 +++----
 .../unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp   | 7 +++----
 .../unique.ptr.modifiers/reset.runtime.fail.cpp            | 7 +++----
 .../unique.ptr.modifiers/reset.single.pass.cpp             | 7 +++----
 .../unique.ptr.modifiers/reset_self.pass.cpp               | 7 +++----
 .../unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp    | 7 +++----
 .../unique.ptr.observers/dereference.runtime.fail.cpp      | 7 +++----
 .../unique.ptr.observers/dereference.single.pass.cpp       | 7 +++----
 .../unique.ptr.observers/explicit_bool.pass.cpp            | 7 +++----
 .../unique.ptr.class/unique.ptr.observers/get.pass.cpp     | 7 +++----
 .../unique.ptr.observers/get_deleter.pass.cpp              | 7 +++----
 .../unique.ptr.observers/op_arrow.runtime.fail.cpp         | 7 +++----
 .../unique.ptr.observers/op_arrow.single.pass.cpp          | 7 +++----
 .../unique.ptr.observers/op_subscript.runtime.pass.cpp     | 7 +++----
 .../unique.ptr.observers/op_subscript.single.fail.cpp      | 7 +++----
 .../unique.ptr.create/make_unique.array.pass.cpp           | 7 +++----
 .../unique.ptr.create/make_unique.array1.fail.cpp          | 7 +++----
 .../unique.ptr.create/make_unique.array2.fail.cpp          | 7 +++----
 .../unique.ptr.create/make_unique.array3.fail.cpp          | 7 +++----
 .../unique.ptr.create/make_unique.array4.fail.cpp          | 7 +++----
 .../unique.ptr.create/make_unique.single.pass.cpp          | 7 +++----
 .../unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp      | 7 +++----
 .../unique.ptr.dltr.dflt/convert_ctor.pass.cpp             | 7 +++----
 .../unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp  | 7 +++----
 .../unique.ptr.dltr.dflt/incomplete.fail.cpp               | 7 +++----
 .../unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp     | 7 +++----
 .../unique.ptr.dltr.dflt1/convert_ctor.fail.cpp            | 7 +++----
 .../unique.ptr.dltr.dflt1/convert_ctor.pass.cpp            | 7 +++----
 .../unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp | 7 +++----
 .../unique.ptr.dltr.dflt1/incomplete.fail.cpp              | 7 +++----
 .../unique.ptr.dltr.general/nothing_to_do.pass.cpp         | 7 +++----
 .../unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp     | 7 +++----
 .../smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp     | 7 +++----
 .../smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp    | 7 +++----
 .../smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp   | 7 +++----
 .../template.bitset/bitset.cons/char_ptr_ctor.pass.cpp     | 7 +++----
 .../utilities/template.bitset/bitset.cons/default.pass.cpp | 7 +++----
 .../template.bitset/bitset.cons/string_ctor.pass.cpp       | 7 +++----
 .../template.bitset/bitset.cons/ull_ctor.pass.cpp          | 7 +++----
 .../utilities/template.bitset/bitset.hash/bitset.pass.cpp  | 7 +++----
 .../template.bitset/bitset.hash/enabled_hash.pass.cpp      | 7 +++----
 .../utilities/template.bitset/bitset.members/all.pass.cpp  | 7 +++----
 .../utilities/template.bitset/bitset.members/any.pass.cpp  | 7 +++----
 .../template.bitset/bitset.members/count.pass.cpp          | 7 +++----
 .../template.bitset/bitset.members/flip_all.pass.cpp       | 7 +++----
 .../template.bitset/bitset.members/flip_one.pass.cpp       | 7 +++----
 .../template.bitset/bitset.members/index.pass.cpp          | 7 +++----
 .../template.bitset/bitset.members/index_const.pass.cpp    | 7 +++----
 .../template.bitset/bitset.members/left_shift.pass.cpp     | 7 +++----
 .../template.bitset/bitset.members/left_shift_eq.pass.cpp  | 7 +++----
 .../utilities/template.bitset/bitset.members/none.pass.cpp | 7 +++----
 .../template.bitset/bitset.members/not_all.pass.cpp        | 7 +++----
 .../template.bitset/bitset.members/op_and_eq.pass.cpp      | 7 +++----
 .../template.bitset/bitset.members/op_eq_eq.pass.cpp       | 7 +++----
 .../template.bitset/bitset.members/op_or_eq.pass.cpp       | 7 +++----
 .../template.bitset/bitset.members/op_xor_eq.pass.cpp      | 7 +++----
 .../template.bitset/bitset.members/reset_all.pass.cpp      | 7 +++----
 .../template.bitset/bitset.members/reset_one.pass.cpp      | 7 +++----
 .../template.bitset/bitset.members/right_shift.pass.cpp    | 7 +++----
 .../template.bitset/bitset.members/right_shift_eq.pass.cpp | 7 +++----
 .../template.bitset/bitset.members/set_all.pass.cpp        | 7 +++----
 .../template.bitset/bitset.members/set_one.pass.cpp        | 7 +++----
 .../utilities/template.bitset/bitset.members/size.pass.cpp | 7 +++----
 .../utilities/template.bitset/bitset.members/test.pass.cpp | 7 +++----
 .../template.bitset/bitset.members/to_string.pass.cpp      | 7 +++----
 .../template.bitset/bitset.members/to_ullong.pass.cpp      | 7 +++----
 .../template.bitset/bitset.members/to_ulong.pass.cpp       | 7 +++----
 .../template.bitset/bitset.operators/op_and.pass.cpp       | 7 +++----
 .../template.bitset/bitset.operators/op_not.pass.cpp       | 7 +++----
 .../template.bitset/bitset.operators/op_or.pass.cpp        | 7 +++----
 .../template.bitset/bitset.operators/stream_in.pass.cpp    | 7 +++----
 .../template.bitset/bitset.operators/stream_out.pass.cpp   | 7 +++----
 test/std/utilities/template.bitset/includes.pass.cpp       | 7 +++----
 test/std/utilities/time/clock.h                            | 7 +++----
 test/std/utilities/time/date.time/ctime.pass.cpp           | 7 +++----
 test/std/utilities/time/days.pass.cpp                      | 7 +++----
 test/std/utilities/time/hours.pass.cpp                     | 7 +++----
 test/std/utilities/time/microseconds.pass.cpp              | 7 +++----
 test/std/utilities/time/milliseconds.pass.cpp              | 7 +++----
 test/std/utilities/time/minutes.pass.cpp                   | 7 +++----
 test/std/utilities/time/months.pass.cpp                    | 7 +++----
 test/std/utilities/time/nanoseconds.pass.cpp               | 7 +++----
 test/std/utilities/time/rep.h                              | 7 +++----
 test/std/utilities/time/seconds.pass.cpp                   | 7 +++----
 test/std/utilities/time/time.cal/euclidian.h               | 7 +++----
 test/std/utilities/time/time.cal/nothing_to_do.pass.cpp    | 7 +++----
 .../time.cal.day/time.cal.day.members/ctor.pass.cpp        | 7 +++----
 .../time.cal.day/time.cal.day.members/decrement.pass.cpp   | 7 +++----
 .../time.cal.day/time.cal.day.members/increment.pass.cpp   | 7 +++----
 .../time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp | 7 +++----
 .../time.cal.day.members/plus_minus_equal.pass.cpp         | 7 +++----
 .../time.cal.day.nonmembers/comparisons.pass.cpp           | 7 +++----
 .../time.cal.day/time.cal.day.nonmembers/literals.fail.cpp | 7 +++----
 .../time.cal.day/time.cal.day.nonmembers/literals.pass.cpp | 7 +++----
 .../time.cal.day/time.cal.day.nonmembers/minus.pass.cpp    | 7 +++----
 .../time.cal.day/time.cal.day.nonmembers/plus.pass.cpp     | 7 +++----
 .../time.cal.day.nonmembers/streaming.pass.cpp             | 7 +++----
 .../utilities/time/time.cal/time.cal.day/types.pass.cpp    | 7 +++----
 .../utilities/time/time.cal/time.cal.last/types.pass.cpp   | 7 +++----
 .../time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp | 7 +++----
 .../time.cal/time.cal.md/time.cal.md.members/day.pass.cpp  | 7 +++----
 .../time.cal.md/time.cal.md.members/month.pass.cpp         | 7 +++----
 .../time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp   | 7 +++----
 .../time.cal.md.nonmembers/comparisons.pass.cpp            | 7 +++----
 .../time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp  | 7 +++----
 .../std/utilities/time/time.cal/time.cal.md/types.pass.cpp | 7 +++----
 .../time/time.cal/time.cal.mdlast/comparisons.pass.cpp     | 7 +++----
 .../utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp  | 7 +++----
 .../utilities/time/time.cal/time.cal.mdlast/month.pass.cpp | 7 +++----
 .../utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp    | 7 +++----
 .../time/time.cal/time.cal.mdlast/streaming.pass.cpp       | 7 +++----
 .../utilities/time/time.cal/time.cal.mdlast/types.pass.cpp | 7 +++----
 .../time.cal.month/time.cal.month.members/ctor.pass.cpp    | 7 +++----
 .../time.cal.month.members/decrement.pass.cpp              | 7 +++----
 .../time.cal.month.members/increment.pass.cpp              | 7 +++----
 .../time.cal.month/time.cal.month.members/ok.pass.cpp      | 7 +++----
 .../time.cal.month.members/plus_minus_equal.pass.cpp       | 7 +++----
 .../time.cal.month.nonmembers/comparisons.pass.cpp         | 7 +++----
 .../time.cal.month.nonmembers/literals.pass.cpp            | 7 +++----
 .../time.cal.month.nonmembers/minus.pass.cpp               | 7 +++----
 .../time.cal.month/time.cal.month.nonmembers/plus.pass.cpp | 7 +++----
 .../time.cal.month.nonmembers/streaming.pass.cpp           | 7 +++----
 .../utilities/time/time.cal/time.cal.month/types.pass.cpp  | 7 +++----
 .../time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp        | 7 +++----
 .../time.cal.mwd/time.cal.mwd.members/month.pass.cpp       | 7 +++----
 .../time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp | 7 +++----
 .../time.cal.mwd.members/weekday_indexed.pass.cpp          | 7 +++----
 .../time.cal.mwd.nonmembers/comparisons.pass.cpp           | 7 +++----
 .../time.cal.mwd.nonmembers/streaming.pass.cpp             | 7 +++----
 .../utilities/time/time.cal/time.cal.mwd/types.pass.cpp    | 7 +++----
 .../time.cal.mwdlast.members/ctor.pass.cpp                 | 7 +++----
 .../time.cal.mwdlast.members/month.pass.cpp                | 7 +++----
 .../time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp  | 7 +++----
 .../time.cal.mwdlast.members/weekday_last.pass.cpp         | 7 +++----
 .../time.cal.mwdlast.nonmembers/comparisons.pass.cpp       | 7 +++----
 .../time.cal.mwdlast.nonmembers/streaming.pass.cpp         | 7 +++----
 .../time/time.cal/time.cal.mwdlast/types.pass.cpp          | 7 +++----
 .../time/time.cal/time.cal.operators/month_day.pass.cpp    | 7 +++----
 .../time.cal/time.cal.operators/month_day_last.pass.cpp    | 7 +++----
 .../time.cal/time.cal.operators/month_weekday.pass.cpp     | 7 +++----
 .../time.cal.operators/month_weekday_last.pass.cpp         | 7 +++----
 .../time/time.cal/time.cal.operators/year_month.pass.cpp   | 7 +++----
 .../time.cal/time.cal.operators/year_month_day.pass.cpp    | 7 +++----
 .../time.cal.operators/year_month_day_last.pass.cpp        | 7 +++----
 .../time.cal.operators/year_month_weekday.pass.cpp         | 7 +++----
 .../time.cal.operators/year_month_weekday_last.pass.cpp    | 7 +++----
 .../time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp    | 7 +++----
 .../time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp   | 7 +++----
 .../time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp      | 7 +++----
 .../time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp | 7 +++----
 .../time.cal.wdidx.nonmembers/comparisons.pass.cpp         | 7 +++----
 .../time.cal.wdidx.nonmembers/streaming.pass.cpp           | 7 +++----
 .../utilities/time/time.cal/time.cal.wdidx/types.pass.cpp  | 7 +++----
 .../time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp  | 7 +++----
 .../time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp    | 7 +++----
 .../time.cal.wdlast.members/weekday.pass.cpp               | 7 +++----
 .../time.cal.wdlast.nonmembers/comparisons.pass.cpp        | 7 +++----
 .../time.cal.wdlast.nonmembers/streaming.pass.cpp          | 7 +++----
 .../utilities/time/time.cal/time.cal.wdlast/types.pass.cpp | 7 +++----
 .../time.cal.weekday.members/ctor.local_days.pass.cpp      | 7 +++----
 .../time.cal.weekday.members/ctor.pass.cpp                 | 7 +++----
 .../time.cal.weekday.members/ctor.sys_days.pass.cpp        | 7 +++----
 .../time.cal.weekday.members/decrement.pass.cpp            | 7 +++----
 .../time.cal.weekday.members/increment.pass.cpp            | 7 +++----
 .../time.cal.weekday/time.cal.weekday.members/ok.pass.cpp  | 7 +++----
 .../time.cal.weekday.members/operator[].pass.cpp           | 7 +++----
 .../time.cal.weekday.members/plus_minus_equal.pass.cpp     | 7 +++----
 .../time.cal.weekday.nonmembers/comparisons.pass.cpp       | 7 +++----
 .../time.cal.weekday.nonmembers/literals.pass.cpp          | 7 +++----
 .../time.cal.weekday.nonmembers/minus.pass.cpp             | 7 +++----
 .../time.cal.weekday.nonmembers/plus.pass.cpp              | 7 +++----
 .../time.cal.weekday.nonmembers/streaming.pass.cpp         | 7 +++----
 .../time/time.cal/time.cal.weekday/types.pass.cpp          | 7 +++----
 .../time.cal.year/time.cal.year.members/ctor.pass.cpp      | 7 +++----
 .../time.cal.year/time.cal.year.members/decrement.pass.cpp | 7 +++----
 .../time.cal.year/time.cal.year.members/increment.pass.cpp | 7 +++----
 .../time.cal.year/time.cal.year.members/is_leap.pass.cpp   | 7 +++----
 .../time.cal.year/time.cal.year.members/ok.pass.cpp        | 7 +++----
 .../time.cal.year.members/plus_minus.pass.cpp              | 7 +++----
 .../time.cal.year.members/plus_minus_equal.pass.cpp        | 7 +++----
 .../time.cal.year.nonmembers/comparisons.pass.cpp          | 7 +++----
 .../time.cal.year.nonmembers/literals.fail.cpp             | 7 +++----
 .../time.cal.year.nonmembers/literals.pass.cpp             | 7 +++----
 .../time.cal.year/time.cal.year.nonmembers/minus.pass.cpp  | 7 +++----
 .../time.cal.year/time.cal.year.nonmembers/plus.pass.cpp   | 7 +++----
 .../time.cal.year.nonmembers/streaming.pass.cpp            | 7 +++----
 .../utilities/time/time.cal/time.cal.year/types.pass.cpp   | 7 +++----
 .../time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp | 7 +++----
 .../time.cal.ym/time.cal.ym.members/month.pass.cpp         | 7 +++----
 .../time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp   | 7 +++----
 .../time.cal.ym.members/plus_minus_equal_month.pass.cpp    | 7 +++----
 .../time.cal.ym.members/plus_minus_equal_year.pass.cpp     | 7 +++----
 .../time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp | 7 +++----
 .../time.cal.ym.nonmembers/comparisons.pass.cpp            | 7 +++----
 .../time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp      | 7 +++----
 .../time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp       | 7 +++----
 .../time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp  | 7 +++----
 .../std/utilities/time/time.cal/time.cal.ym/types.pass.cpp | 7 +++----
 .../time.cal.ymd.members/ctor.local_days.pass.cpp          | 7 +++----
 .../time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp        | 7 +++----
 .../time.cal.ymd.members/ctor.sys_days.pass.cpp            | 7 +++----
 .../time.cal.ymd.members/ctor.year_month_day_last.pass.cpp | 7 +++----
 .../time.cal.ymd/time.cal.ymd.members/day.pass.cpp         | 7 +++----
 .../time.cal.ymd/time.cal.ymd.members/month.pass.cpp       | 7 +++----
 .../time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp | 7 +++----
 .../time.cal.ymd.members/op.local_days.pass.cpp            | 7 +++----
 .../time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp | 7 +++----
 .../time.cal.ymd.members/plus_minus_equal_month.pass.cpp   | 7 +++----
 .../time.cal.ymd.members/plus_minus_equal_year.pass.cpp    | 7 +++----
 .../time.cal.ymd/time.cal.ymd.members/year.pass.cpp        | 7 +++----
 .../time.cal.ymd.nonmembers/comparisons.pass.cpp           | 7 +++----
 .../time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp    | 7 +++----
 .../time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp     | 7 +++----
 .../time.cal.ymd.nonmembers/streaming.pass.cpp             | 7 +++----
 .../utilities/time/time.cal/time.cal.ymd/types.pass.cpp    | 7 +++----
 .../time.cal.ymdlast.members/ctor.pass.cpp                 | 7 +++----
 .../time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp | 7 +++----
 .../time.cal.ymdlast.members/month.pass.cpp                | 7 +++----
 .../time.cal.ymdlast.members/month_day_last.pass.cpp       | 7 +++----
 .../time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp  | 7 +++----
 .../time.cal.ymdlast.members/op_local_days.pass.cpp        | 7 +++----
 .../time.cal.ymdlast.members/op_sys_days.pass.cpp          | 7 +++----
 .../plus_minus_equal_month.pass.cpp                        | 7 +++----
 .../plus_minus_equal_year.pass.cpp                         | 7 +++----
 .../time.cal.ymdlast.members/year.pass.cpp                 | 7 +++----
 .../time.cal.ymdlast.nonmembers/comparisons.pass.cpp       | 7 +++----
 .../time.cal.ymdlast.nonmembers/minus.pass.cpp             | 7 +++----
 .../time.cal.ymdlast.nonmembers/plus.pass.cpp              | 7 +++----
 .../time.cal.ymdlast.nonmembers/streaming.pass.cpp         | 7 +++----
 .../time.cal.ymwd.members/ctor.local_days.pass.cpp         | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp      | 7 +++----
 .../time.cal.ymwd.members/ctor.sys_days.pass.cpp           | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp     | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp     | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp        | 7 +++----
 .../time.cal.ymwd.members/op.local_days.pass.cpp           | 7 +++----
 .../time.cal.ymwd.members/op.sys_days.pass.cpp             | 7 +++----
 .../time.cal.ymwd.members/plus_minus_equal_month.pass.cpp  | 7 +++----
 .../time.cal.ymwd.members/plus_minus_equal_year.pass.cpp   | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp   | 7 +++----
 .../time.cal.ymwd.members/weekday_indexed.pass.cpp         | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp      | 7 +++----
 .../time.cal.ymwd.nonmembers/comparisons.pass.cpp          | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp  | 7 +++----
 .../time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp   | 7 +++----
 .../time.cal.ymwd.nonmembers/streaming.pass.cpp            | 7 +++----
 .../utilities/time/time.cal/time.cal.ymwd/types.pass.cpp   | 7 +++----
 .../time.cal.ymwdlast.members/ctor.pass.cpp                | 7 +++----
 .../time.cal.ymwdlast.members/month.pass.cpp               | 7 +++----
 .../time.cal.ymwdlast.members/ok.pass.cpp                  | 7 +++----
 .../time.cal.ymwdlast.members/op_local_days.pass.cpp       | 7 +++----
 .../time.cal.ymwdlast.members/op_sys_days.pass.cpp         | 7 +++----
 .../plus_minus_equal_month.pass.cpp                        | 7 +++----
 .../plus_minus_equal_year.pass.cpp                         | 7 +++----
 .../time.cal.ymwdlast.members/weekday.pass.cpp             | 7 +++----
 .../time.cal.ymwdlast.members/year.pass.cpp                | 7 +++----
 .../time.cal.ymwdlast.nonmembers/comparisons.pass.cpp      | 7 +++----
 .../time.cal.ymwdlast.nonmembers/minus.pass.cpp            | 7 +++----
 .../time.cal.ymwdlast.nonmembers/plus.pass.cpp             | 7 +++----
 .../time.cal.ymwdlast.nonmembers/streaming.pass.cpp        | 7 +++----
 .../time/time.cal/time.cal.ymwdlast/types.pass.cpp         | 7 +++----
 .../utilities/time/time.clock.req/nothing_to_do.pass.cpp   | 7 +++----
 test/std/utilities/time/time.clock/nothing_to_do.pass.cpp  | 7 +++----
 .../time/time.clock/time.clock.file/consistency.pass.cpp   | 7 +++----
 .../time/time.clock/time.clock.file/file_time.pass.cpp     | 7 +++----
 .../utilities/time/time.clock/time.clock.file/now.pass.cpp | 7 +++----
 .../time/time.clock/time.clock.file/rep_signed.pass.cpp    | 7 +++----
 .../time/time.clock/time.clock.hires/consistency.pass.cpp  | 7 +++----
 .../time/time.clock/time.clock.hires/now.pass.cpp          | 7 +++----
 .../time/time.clock/time.clock.steady/consistency.pass.cpp | 7 +++----
 .../time/time.clock/time.clock.steady/now.pass.cpp         | 7 +++----
 .../time/time.clock/time.clock.system/consistency.pass.cpp | 7 +++----
 .../time/time.clock/time.clock.system/from_time_t.pass.cpp | 7 +++----
 .../time.clock/time.clock.system/local_time.types.pass.cpp | 7 +++----
 .../time/time.clock/time.clock.system/now.pass.cpp         | 7 +++----
 .../time/time.clock/time.clock.system/rep_signed.pass.cpp  | 7 +++----
 .../time.clock/time.clock.system/sys.time.types.pass.cpp   | 7 +++----
 .../time/time.clock/time.clock.system/to_time_t.pass.cpp   | 7 +++----
 .../utilities/time/time.duration/default_ratio.pass.cpp    | 7 +++----
 test/std/utilities/time/time.duration/duration.fail.cpp    | 7 +++----
 .../std/utilities/time/time.duration/positive_num.fail.cpp | 7 +++----
 test/std/utilities/time/time.duration/ratio.fail.cpp       | 7 +++----
 .../time/time.duration/time.duration.alg/abs.fail.cpp      | 7 +++----
 .../time/time.duration/time.duration.alg/abs.pass.cpp      | 7 +++----
 .../time.duration/time.duration.arithmetic/op_++.pass.cpp  | 7 +++----
 .../time.duration.arithmetic/op_++int.pass.cpp             | 7 +++----
 .../time.duration/time.duration.arithmetic/op_+.pass.cpp   | 7 +++----
 .../time.duration/time.duration.arithmetic/op_+=.pass.cpp  | 7 +++----
 .../time.duration/time.duration.arithmetic/op_--.pass.cpp  | 7 +++----
 .../time.duration.arithmetic/op_--int.pass.cpp             | 7 +++----
 .../time.duration/time.duration.arithmetic/op_-.pass.cpp   | 7 +++----
 .../time.duration/time.duration.arithmetic/op_-=.pass.cpp  | 7 +++----
 .../time.duration.arithmetic/op_divide=.pass.cpp           | 7 +++----
 .../time.duration.arithmetic/op_mod=duration.pass.cpp      | 7 +++----
 .../time.duration.arithmetic/op_mod=rep.pass.cpp           | 7 +++----
 .../time.duration.arithmetic/op_times=.pass.cpp            | 7 +++----
 .../time/time.duration/time.duration.cast/ceil.fail.cpp    | 7 +++----
 .../time/time.duration/time.duration.cast/ceil.pass.cpp    | 7 +++----
 .../time.duration.cast/duration_cast.pass.cpp              | 7 +++----
 .../time/time.duration/time.duration.cast/floor.fail.cpp   | 7 +++----
 .../time/time.duration/time.duration.cast/floor.pass.cpp   | 7 +++----
 .../time/time.duration/time.duration.cast/round.fail.cpp   | 7 +++----
 .../time/time.duration/time.duration.cast/round.pass.cpp   | 7 +++----
 .../time.duration/time.duration.cast/toduration.fail.cpp   | 7 +++----
 .../time.duration.comparisons/op_equal.pass.cpp            | 7 +++----
 .../time.duration.comparisons/op_less.pass.cpp             | 7 +++----
 .../time.duration.cons/convert_exact.pass.cpp              | 7 +++----
 .../time.duration.cons/convert_float_to_int.fail.cpp       | 7 +++----
 .../time.duration.cons/convert_inexact.fail.cpp            | 7 +++----
 .../time.duration.cons/convert_inexact.pass.cpp            | 7 +++----
 .../time.duration.cons/convert_int_to_float.pass.cpp       | 7 +++----
 .../time.duration.cons/convert_overflow.pass.cpp           | 7 +++----
 .../time/time.duration/time.duration.cons/default.pass.cpp | 7 +++----
 .../time/time.duration/time.duration.cons/rep.pass.cpp     | 7 +++----
 .../time/time.duration/time.duration.cons/rep01.fail.cpp   | 7 +++----
 .../time/time.duration/time.duration.cons/rep02.fail.cpp   | 7 +++----
 .../time/time.duration/time.duration.cons/rep02.pass.cpp   | 7 +++----
 .../time/time.duration/time.duration.cons/rep03.fail.cpp   | 7 +++----
 .../time.duration/time.duration.literals/literals.pass.cpp | 7 +++----
 .../time.duration.literals/literals1.fail.cpp              | 7 +++----
 .../time.duration.literals/literals1.pass.cpp              | 7 +++----
 .../time.duration.literals/literals2.fail.cpp              | 7 +++----
 .../time.duration.literals/literals2.pass.cpp              | 7 +++----
 .../time.duration/time.duration.nonmember/op_+.pass.cpp    | 7 +++----
 .../time.duration/time.duration.nonmember/op_-.pass.cpp    | 7 +++----
 .../time.duration.nonmember/op_divide_duration.pass.cpp    | 7 +++----
 .../time.duration.nonmember/op_divide_rep.fail.cpp         | 7 +++----
 .../time.duration.nonmember/op_divide_rep.pass.cpp         | 7 +++----
 .../time.duration.nonmember/op_mod_duration.pass.cpp       | 7 +++----
 .../time.duration.nonmember/op_mod_rep.fail.cpp            | 7 +++----
 .../time.duration.nonmember/op_mod_rep.pass.cpp            | 7 +++----
 .../time.duration.nonmember/op_times_rep.pass.cpp          | 7 +++----
 .../time.duration.nonmember/op_times_rep1.fail.cpp         | 7 +++----
 .../time.duration.nonmember/op_times_rep2.fail.cpp         | 7 +++----
 .../time.duration.observer/tested_elsewhere.pass.cpp       | 7 +++----
 .../time/time.duration/time.duration.special/max.pass.cpp  | 7 +++----
 .../time/time.duration/time.duration.special/min.pass.cpp  | 7 +++----
 .../time/time.duration/time.duration.special/zero.pass.cpp | 7 +++----
 test/std/utilities/time/time.duration/types.pass.cpp       | 7 +++----
 .../utilities/time/time.point/default_duration.pass.cpp    | 7 +++----
 test/std/utilities/time/time.point/duration.fail.cpp       | 7 +++----
 .../time/time.point/time.point.arithmetic/op_+=.pass.cpp   | 7 +++----
 .../time/time.point/time.point.arithmetic/op_-=.pass.cpp   | 7 +++----
 .../time/time.point/time.point.cast/ceil.fail.cpp          | 7 +++----
 .../time/time.point/time.point.cast/ceil.pass.cpp          | 7 +++----
 .../time/time.point/time.point.cast/floor.fail.cpp         | 7 +++----
 .../time/time.point/time.point.cast/floor.pass.cpp         | 7 +++----
 .../time/time.point/time.point.cast/round.fail.cpp         | 7 +++----
 .../time/time.point/time.point.cast/round.pass.cpp         | 7 +++----
 .../time.point/time.point.cast/time_point_cast.pass.cpp    | 7 +++----
 .../time/time.point/time.point.cast/toduration.fail.cpp    | 7 +++----
 .../time.point/time.point.comparisons/op_equal.fail.cpp    | 7 +++----
 .../time.point/time.point.comparisons/op_equal.pass.cpp    | 7 +++----
 .../time.point/time.point.comparisons/op_less.fail.cpp     | 7 +++----
 .../time.point/time.point.comparisons/op_less.pass.cpp     | 7 +++----
 .../time/time.point/time.point.cons/convert.fail.cpp       | 7 +++----
 .../time/time.point/time.point.cons/convert.pass.cpp       | 7 +++----
 .../time/time.point/time.point.cons/default.pass.cpp       | 7 +++----
 .../time/time.point/time.point.cons/duration.fail.cpp      | 7 +++----
 .../time/time.point/time.point.cons/duration.pass.cpp      | 7 +++----
 .../time/time.point/time.point.nonmember/op_+.pass.cpp     | 7 +++----
 .../time.point/time.point.nonmember/op_-duration.pass.cpp  | 7 +++----
 .../time.point.nonmember/op_-time_point.pass.cpp           | 7 +++----
 .../time.point.observer/tested_elsewhere.pass.cpp          | 7 +++----
 .../time/time.point/time.point.special/max.pass.cpp        | 7 +++----
 .../time/time.point/time.point.special/min.pass.cpp        | 7 +++----
 test/std/utilities/time/time.traits/nothing_to_do.pass.cpp | 7 +++----
 .../time.traits/time.traits.duration_values/max.pass.cpp   | 7 +++----
 .../time.traits/time.traits.duration_values/min.pass.cpp   | 7 +++----
 .../time.traits/time.traits.duration_values/zero.pass.cpp  | 7 +++----
 .../time.traits.is_fp/treat_as_floating_point.pass.cpp     | 7 +++----
 .../time.traits.specializations/duration.pass.cpp          | 7 +++----
 .../time.traits.specializations/time_point.pass.cpp        | 7 +++----
 test/std/utilities/time/weeks.pass.cpp                     | 7 +++----
 test/std/utilities/time/years.pass.cpp                     | 7 +++----
 test/std/utilities/tuple/tuple.general/ignore.pass.cpp     | 7 +++----
 .../utilities/tuple/tuple.general/tuple.smartptr.pass.cpp  | 7 +++----
 .../std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp | 7 +++----
 test/std/utilities/tuple/tuple.tuple/alloc_first.h         | 7 +++----
 test/std/utilities/tuple/tuple.tuple/alloc_last.h          | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp | 7 +++----
 .../tuple.tuple/tuple.apply/apply_extended_types.pass.cpp  | 7 +++----
 .../tuple.tuple/tuple.apply/apply_large_arity.pass.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp | 7 +++----
 .../tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp   | 7 +++----
 .../tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp   | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp | 7 +++----
 .../tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp      | 7 +++----
 .../tuple.assign/tuple_array_template_depth.pass.cpp       | 7 +++----
 .../PR20855_tuple_ref_binding_diagnostics.pass.cpp         | 7 +++----
 .../tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp | 7 +++----
 .../tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp     | 7 +++----
 .../PR27684_contains_ref_to_incomplete_type.pass.cpp       | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp         | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp          | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp          | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp    | 7 +++----
 .../tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp     | 7 +++----
 .../tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp     | 7 +++----
 .../tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp      | 7 +++----
 .../tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp    | 7 +++----
 .../tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp    | 7 +++----
 .../tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp    | 7 +++----
 .../tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp    | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp      | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp      | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp    | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp      | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp    | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp    | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp  | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp  | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/default.pass.cpp         | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp  | 7 +++----
 .../tuple.cnstr/implicit_deduction_guides.pass.cpp         | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp  | 7 +++----
 .../tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp       | 7 +++----
 .../tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp      | 7 +++----
 .../tuple.cnstr/tuple_array_template_depth.pass.cpp        | 7 +++----
 .../tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp   | 7 +++----
 .../tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp   | 7 +++----
 .../tuple/tuple.tuple/tuple.creation/tie.pass.cpp          | 7 +++----
 .../tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp    | 7 +++----
 .../tuple/tuple.tuple/tuple.elem/get_const.fail.cpp        | 7 +++----
 .../tuple/tuple.tuple/tuple.elem/get_const.pass.cpp        | 7 +++----
 .../tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp    | 7 +++----
 .../utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp | 7 +++----
 .../tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp    | 7 +++----
 .../tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp    | 7 +++----
 .../tuple.tuple/tuple.helper/tuple.include.array.pass.cpp  | 7 +++----
 .../tuple.helper/tuple.include.utility.pass.cpp            | 7 +++----
 .../tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp  | 7 +++----
 .../tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp  | 7 +++----
 .../tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp     | 7 +++----
 .../tuple.helper/tuple_size_incomplete.fail.cpp            | 7 +++----
 .../tuple.helper/tuple_size_incomplete.pass.cpp            | 7 +++----
 .../tuple.helper/tuple_size_structured_bindings.pass.cpp   | 7 +++----
 .../tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp   | 7 +++----
 .../tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp   | 7 +++----
 .../tuple.helper/tuple_size_value_sfinae.pass.cpp          | 7 +++----
 test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp | 7 +++----
 test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp | 7 +++----
 .../tuple.tuple/tuple.special/non_member_swap.pass.cpp     | 7 +++----
 .../tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp      | 7 +++----
 .../tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp | 7 +++----
 .../type.index/type.index.hash/enabled_hash.pass.cpp       | 7 +++----
 .../std/utilities/type.index/type.index.hash/hash.pass.cpp | 7 +++----
 .../utilities/type.index/type.index.members/ctor.pass.cpp  | 7 +++----
 .../utilities/type.index/type.index.members/eq.pass.cpp    | 7 +++----
 .../type.index/type.index.members/hash_code.pass.cpp       | 7 +++----
 .../utilities/type.index/type.index.members/lt.pass.cpp    | 7 +++----
 .../utilities/type.index/type.index.members/name.pass.cpp  | 7 +++----
 .../type.index/type.index.overview/copy_assign.pass.cpp    | 7 +++----
 .../type.index/type.index.overview/copy_ctor.pass.cpp      | 7 +++----
 .../type.index.synopsis/hash_type_index.pass.cpp           | 7 +++----
 .../std/utilities/utilities.general/nothing_to_do.pass.cpp | 7 +++----
 .../allocator.requirements/nothing_to_do.pass.cpp          | 7 +++----
 .../hash.requirements/nothing_to_do.pass.cpp               | 7 +++----
 .../utilities/utility.requirements/nothing_to_do.pass.cpp  | 7 +++----
 .../nullablepointer.requirements/nothing_to_do.pass.cpp    | 7 +++----
 .../swappable.requirements/nothing_to_do.pass.cpp          | 7 +++----
 .../utility.arg.requirements/nothing_to_do.pass.cpp        | 7 +++----
 test/std/utilities/utility/as_const/as_const.fail.cpp      | 7 +++----
 test/std/utilities/utility/as_const/as_const.pass.cpp      | 7 +++----
 test/std/utilities/utility/declval/declval.pass.cpp        | 7 +++----
 test/std/utilities/utility/exchange/exchange.pass.cpp      | 7 +++----
 test/std/utilities/utility/forward/forward.fail.cpp        | 7 +++----
 test/std/utilities/utility/forward/forward.pass.cpp        | 7 +++----
 test/std/utilities/utility/forward/forward_03.pass.cpp     | 7 +++----
 test/std/utilities/utility/forward/move.fail.cpp           | 7 +++----
 test/std/utilities/utility/forward/move.pass.cpp           | 7 +++----
 .../utilities/utility/forward/move_if_noexcept.pass.cpp    | 7 +++----
 test/std/utilities/utility/operators/rel_ops.pass.cpp      | 7 +++----
 test/std/utilities/utility/pairs/nothing_to_do.pass.cpp    | 7 +++----
 .../utility/pairs/pair.astuple/get_const.fail.cpp          | 7 +++----
 .../utility/pairs/pair.astuple/get_const.pass.cpp          | 7 +++----
 .../utility/pairs/pair.astuple/get_const_rv.pass.cpp       | 7 +++----
 .../utility/pairs/pair.astuple/get_non_const.pass.cpp      | 7 +++----
 .../utilities/utility/pairs/pair.astuple/get_rv.pass.cpp   | 7 +++----
 .../utility/pairs/pair.astuple/pairs.by.type.pass.cpp      | 7 +++----
 .../utility/pairs/pair.astuple/pairs.by.type1.fail.cpp     | 7 +++----
 .../utility/pairs/pair.astuple/pairs.by.type2.fail.cpp     | 7 +++----
 .../utility/pairs/pair.astuple/pairs.by.type3.fail.cpp     | 7 +++----
 .../utility/pairs/pair.astuple/tuple_element.fail.cpp      | 7 +++----
 .../utility/pairs/pair.astuple/tuple_element.pass.cpp      | 7 +++----
 .../utility/pairs/pair.astuple/tuple_size.pass.cpp         | 7 +++----
 .../pairs/pair.piecewise/piecewise_construct.pass.cpp      | 7 +++----
 .../utility/pairs/pairs.general/nothing_to_do.pass.cpp     | 7 +++----
 test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp   | 7 +++----
 .../pairs/pairs.pair/assign_const_pair_U_V.pass.cpp        | 7 +++----
 .../utility/pairs/pairs.pair/assign_pair.pass.cpp          | 7 +++----
 .../utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp    | 7 +++----
 .../utility/pairs/pairs.pair/assign_rv_pair.pass.cpp       | 7 +++----
 .../utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp   | 7 +++----
 .../pairs/pairs.pair/const_first_const_second.pass.cpp     | 7 +++----
 .../pairs.pair/const_first_const_second_cxx03.pass.cpp     | 7 +++----
 .../utility/pairs/pairs.pair/const_pair_U_V.pass.cpp       | 7 +++----
 .../utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp | 7 +++----
 .../utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp  | 7 +++----
 .../utility/pairs/pairs.pair/default-sfinae.pass.cpp       | 7 +++----
 .../utilities/utility/pairs/pairs.pair/default.pass.cpp    | 7 +++----
 test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp  | 7 +++----
 .../pairs/pairs.pair/implicit_deduction_guides.pass.cpp    | 7 +++----
 .../utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp  | 7 +++----
 .../utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp  | 7 +++----
 .../utilities/utility/pairs/pairs.pair/piecewise.pass.cpp  | 7 +++----
 .../utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp          | 7 +++----
 .../pairs.pair/special_member_generation_test.pass.cpp     | 7 +++----
 test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp  | 7 +++----
 .../utility/pairs/pairs.pair/trivial_copy_move.pass.cpp    | 7 +++----
 test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp | 7 +++----
 test/std/utilities/utility/synopsis.pass.cpp               | 7 +++----
 .../std/utilities/utility/utility.inplace/inplace.pass.cpp | 7 +++----
 test/std/utilities/utility/utility.swap/swap.pass.cpp      | 7 +++----
 .../std/utilities/utility/utility.swap/swap_array.pass.cpp | 7 +++----
 .../variant.bad_variant_access/bad_variant_access.pass.cpp | 7 +++----
 .../variant/variant.general/nothing_to_do.pass.cpp         | 7 +++----
 .../utilities/variant/variant.get/get_if_index.pass.cpp    | 7 +++----
 .../std/utilities/variant/variant.get/get_if_type.pass.cpp | 7 +++----
 test/std/utilities/variant/variant.get/get_index.pass.cpp  | 7 +++----
 test/std/utilities/variant/variant.get/get_type.pass.cpp   | 7 +++----
 .../variant/variant.get/holds_alternative.pass.cpp         | 7 +++----
 .../utilities/variant/variant.hash/enabled_hash.pass.cpp   | 7 +++----
 test/std/utilities/variant/variant.hash/hash.pass.cpp      | 7 +++----
 .../variant/variant.helpers/variant_alternative.fail.cpp   | 7 +++----
 .../variant/variant.helpers/variant_alternative.pass.cpp   | 7 +++----
 .../variant/variant.helpers/variant_size.pass.cpp          | 7 +++----
 .../variant/variant.monostate.relops/relops.pass.cpp       | 7 +++----
 .../utilities/variant/variant.monostate/monostate.pass.cpp | 7 +++----
 test/std/utilities/variant/variant.relops/relops.pass.cpp  | 7 +++----
 .../variant/variant.relops/relops_bool_conv.fail.cpp       | 7 +++----
 .../variant/variant.synopsis/variant_npos.pass.cpp         | 7 +++----
 .../variant/variant.variant/variant.assign/T.pass.cpp      | 7 +++----
 .../variant/variant.variant/variant.assign/copy.pass.cpp   | 7 +++----
 .../variant/variant.variant/variant.assign/move.pass.cpp   | 7 +++----
 .../variant/variant.variant/variant.ctor/T.pass.cpp        | 7 +++----
 .../variant/variant.variant/variant.ctor/copy.pass.cpp     | 7 +++----
 .../variant/variant.variant/variant.ctor/default.pass.cpp  | 7 +++----
 .../variant.ctor/in_place_index_args.pass.cpp              | 7 +++----
 .../variant.ctor/in_place_index_init_list_args.pass.cpp    | 7 +++----
 .../variant.ctor/in_place_type_args.pass.cpp               | 7 +++----
 .../variant.ctor/in_place_type_init_list_args.pass.cpp     | 7 +++----
 .../variant/variant.variant/variant.ctor/move.pass.cpp     | 7 +++----
 .../variant/variant.variant/variant.dtor/dtor.pass.cpp     | 7 +++----
 .../variant.mod/emplace_index_args.pass.cpp                | 7 +++----
 .../variant.mod/emplace_index_init_list_args.pass.cpp      | 7 +++----
 .../variant.variant/variant.mod/emplace_type_args.pass.cpp | 7 +++----
 .../variant.mod/emplace_type_init_list_args.pass.cpp       | 7 +++----
 .../variant/variant.variant/variant.status/index.pass.cpp  | 7 +++----
 .../variant.status/valueless_by_exception.pass.cpp         | 7 +++----
 .../variant/variant.variant/variant.swap/swap.pass.cpp     | 7 +++----
 .../variant/variant.variant/variant_array.fail.cpp         | 7 +++----
 .../variant/variant.variant/variant_empty.fail.cpp         | 7 +++----
 .../variant/variant.variant/variant_reference.fail.cpp     | 7 +++----
 .../variant/variant.variant/variant_void.fail.cpp          | 7 +++----
 test/std/utilities/variant/variant.visit/visit.pass.cpp    | 7 +++----
 test/support/Counter.h                                     | 7 +++----
 test/support/DefaultOnly.h                                 | 7 +++----
 test/support/MoveOnly.h                                    | 7 +++----
 test/support/allocators.h                                  | 7 +++----
 test/support/any_helpers.h                                 | 7 +++----
 test/support/asan_testing.h                                | 7 +++----
 test/support/charconv_test_helpers.h                       | 7 +++----
 test/support/cmpxchg_loop.h                                | 7 +++----
 test/support/container_test_types.h                        | 7 +++----
 test/support/controlled_allocators.hpp                     | 7 +++----
 test/support/coroutine_types.h                             | 7 +++----
 test/support/count_new.hpp                                 | 7 +++----
 test/support/counting_predicates.hpp                       | 7 +++----
 test/support/debug_mode_helper.h                           | 7 +++----
 test/support/deleter_types.h                               | 7 +++----
 test/support/demangle.h                                    | 7 +++----
 test/support/disable_missing_braces_warning.h              | 7 +++----
 test/support/experimental_any_helpers.h                    | 7 +++----
 test/support/external_threads.cpp                          | 7 +++----
 test/support/hexfloat.h                                    | 7 +++----
 test/support/is_transparent.h                              | 7 +++----
 test/support/min_allocator.h                               | 7 +++----
 test/support/msvc_stdlib_force_include.hpp                 | 7 +++----
 test/support/nasty_containers.hpp                          | 7 +++----
 test/support/nasty_macros.hpp                              | 7 +++----
 test/support/nothing_to_do.pass.cpp                        | 7 +++----
 test/support/platform_support.h                            | 7 +++----
 test/support/poisoned_hash_helper.hpp                      | 7 +++----
 test/support/private_constructor.hpp                       | 7 +++----
 test/support/set_windows_crt_report_mode.h                 | 7 +++----
 test/support/test.support/test_convertible_header.pass.cpp | 7 +++----
 test/support/test.support/test_demangle.pass.cpp           | 7 +++----
 .../test.support/test_macros_header_exceptions.fail.cpp    | 7 +++----
 .../test.support/test_macros_header_exceptions.pass.cpp    | 7 +++----
 test/support/test.support/test_macros_header_rtti.fail.cpp | 7 +++----
 test/support/test.support/test_macros_header_rtti.pass.cpp | 7 +++----
 .../test.support/test_poisoned_hash_helper.pass.cpp        | 7 +++----
 .../c1xx_broken_is_trivially_copyable.pass.cpp             | 7 +++----
 .../test.workarounds/c1xx_broken_za_ctor_check.pass.cpp    | 7 +++----
 test/support/test_allocator.h                              | 7 +++----
 test/support/test_comparisons.h                            | 7 +++----
 test/support/test_convertible.hpp                          | 7 +++----
 test/support/test_iterators.h                              | 7 +++----
 test/support/test_macros.h                                 | 7 +++----
 test/support/test_memory_resource.hpp                      | 7 +++----
 test/support/test_workarounds.h                            | 7 +++----
 test/support/tracked_value.h                               | 7 +++----
 test/support/truncate_fp.h                                 | 7 +++----
 test/support/type_id.h                                     | 7 +++----
 test/support/unique_ptr_test_helper.h                      | 7 +++----
 test/support/user_defined_integral.hpp                     | 7 +++----
 test/support/uses_alloc_types.hpp                          | 7 +++----
 test/support/variant_test_helpers.hpp                      | 7 +++----
 utils/cat_files.py                                         | 7 +++----
 utils/gen_link_script.py                                   | 7 +++----
 utils/libcxx/__init__.py                                   | 7 +++----
 utils/libcxx/compiler.py                                   | 7 +++----
 utils/libcxx/sym_check/__init__.py                         | 7 +++----
 utils/libcxx/sym_check/diff.py                             | 7 +++----
 utils/libcxx/sym_check/extract.py                          | 7 +++----
 utils/libcxx/sym_check/match.py                            | 7 +++----
 utils/libcxx/sym_check/util.py                             | 7 +++----
 utils/libcxx/test/config.py                                | 7 +++----
 utils/libcxx/test/executor.py                              | 7 +++----
 utils/libcxx/test/format.py                                | 7 +++----
 utils/libcxx/test/target_info.py                           | 7 +++----
 utils/libcxx/test/tracing.py                               | 7 +++----
 utils/libcxx/util.py                                       | 7 +++----
 utils/merge_archives.py                                    | 7 +++----
 utils/not.py                                               | 7 +++----
 utils/sym_diff.py                                          | 7 +++----
 utils/sym_extract.py                                       | 7 +++----
 utils/sym_match.py                                         | 7 +++----
 6494 files changed, 19482 insertions(+), 25976 deletions(-)

diff --git a/benchmarks/CartesianBenchmarks.hpp b/benchmarks/CartesianBenchmarks.hpp
index 88a994c55..89b6d854b 100644
--- a/benchmarks/CartesianBenchmarks.hpp
+++ b/benchmarks/CartesianBenchmarks.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/benchmarks/function.bench.cpp b/benchmarks/function.bench.cpp
index 4f0e1fd80..5cc3e7105 100644
--- a/benchmarks/function.bench.cpp
+++ b/benchmarks/function.bench.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/benchmarks/ordered_set.bench.cpp b/benchmarks/ordered_set.bench.cpp
index b2ef0725b..e179aac45 100644
--- a/benchmarks/ordered_set.bench.cpp
+++ b/benchmarks/ordered_set.bench.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/benchmarks/util_smartptr.bench.cpp b/benchmarks/util_smartptr.bench.cpp
index c984b2ca6..053cbd659 100644
--- a/benchmarks/util_smartptr.bench.cpp
+++ b/benchmarks/util_smartptr.bench.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/fuzzing/fuzz_test.cpp b/fuzzing/fuzz_test.cpp
index 98ebe99bf..9fa6f4334 100644
--- a/fuzzing/fuzz_test.cpp
+++ b/fuzzing/fuzz_test.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- fuzz_test.cpp ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/fuzzing/fuzzing.cpp b/fuzzing/fuzzing.cpp
index ad377bcac..5c32f28a3 100644
--- a/fuzzing/fuzzing.cpp
+++ b/fuzzing/fuzzing.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- fuzzing.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/fuzzing/fuzzing.h b/fuzzing/fuzzing.h
index 06f58904b..64103e590 100644
--- a/fuzzing/fuzzing.h
+++ b/fuzzing/fuzzing.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- fuzzing.h --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__bit_reference b/include/__bit_reference
index c208af2b4..4fd1d2f6c 100644
--- a/include/__bit_reference
+++ b/include/__bit_reference
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__bsd_locale_defaults.h b/include/__bsd_locale_defaults.h
index cbc407d10..2ace2a21c 100644
--- a/include/__bsd_locale_defaults.h
+++ b/include/__bsd_locale_defaults.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------- __bsd_locale_defaults.h -----------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // The BSDs have lots of *_l functions.  We don't want to define those symbols
diff --git a/include/__bsd_locale_fallbacks.h b/include/__bsd_locale_fallbacks.h
index 3097b0141..a807fe039 100644
--- a/include/__bsd_locale_fallbacks.h
+++ b/include/__bsd_locale_fallbacks.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------- __bsd_locale_fallbacks.h ----------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // The BSDs have lots of *_l functions.  This file provides reimplementations
diff --git a/include/__config b/include/__config
index f22819b71..1bd593046 100644
--- a/include/__config
+++ b/include/__config
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- __config ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__config_site.in b/include/__config_site.in
index 580a6aa4c..0818d6e1d 100644
--- a/include/__config_site.in
+++ b/include/__config_site.in
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__debug b/include/__debug
index a8788f68f..6ccb72cb8 100644
--- a/include/__debug
+++ b/include/__debug
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- __debug ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__errc b/include/__errc
index d0f00b7f0..a8ad29f36 100644
--- a/include/__errc
+++ b/include/__errc
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- __errc ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__functional_03 b/include/__functional_03
index 0a3bfbaa3..a90cbb75b 100644
--- a/include/__functional_03
+++ b/include/__functional_03
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__functional_base b/include/__functional_base
index 032be99bf..8da832454 100644
--- a/include/__functional_base
+++ b/include/__functional_base
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__functional_base_03 b/include/__functional_base_03
index 8407dcfa3..e6dac90c8 100644
--- a/include/__functional_base_03
+++ b/include/__functional_base_03
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__hash_table b/include/__hash_table
index 6f5b18310..f6b789dc7 100644
--- a/include/__hash_table
+++ b/include/__hash_table
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__locale b/include/__locale
index cde9cc85f..d1d66f94d 100644
--- a/include/__locale
+++ b/include/__locale
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__mutex_base b/include/__mutex_base
index da21a5f8e..008be9594 100644
--- a/include/__mutex_base
+++ b/include/__mutex_base
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__node_handle b/include/__node_handle
index a9cf3b721..7f3bd9da8 100644
--- a/include/__node_handle
+++ b/include/__node_handle
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__nullptr b/include/__nullptr
index aa3b4d214..45529a710 100644
--- a/include/__nullptr
+++ b/include/__nullptr
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- __nullptr --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__sso_allocator b/include/__sso_allocator
index 8aca0495d..393012873 100644
--- a/include/__sso_allocator
+++ b/include/__sso_allocator
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__std_stream b/include/__std_stream
index db90795f6..5a9a470a9 100644
--- a/include/__std_stream
+++ b/include/__std_stream
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__threading_support b/include/__threading_support
index 202490062..baa1222c3 100644
--- a/include/__threading_support
+++ b/include/__threading_support
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__tree b/include/__tree
index 814851085..4144a9599 100644
--- a/include/__tree
+++ b/include/__tree
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/__tuple b/include/__tuple
index 3b23d78af..89134b5d2 100644
--- a/include/__tuple
+++ b/include/__tuple
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/algorithm b/include/algorithm
index d102899f2..310256e61 100644
--- a/include/algorithm
+++ b/include/algorithm
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- algorithm ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/array b/include/array
index 56f688765..05c4b6527 100644
--- a/include/array
+++ b/include/array
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- array -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/bit b/include/bit
index db3812e5b..a2ca3bc83 100644
--- a/include/bit
+++ b/include/bit
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ bit ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 
diff --git a/include/bitset b/include/bitset
index 98947e027..9fb91e9bd 100644
--- a/include/bitset
+++ b/include/bitset
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- bitset ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cassert b/include/cassert
index 377599064..25a0a746b 100644
--- a/include/cassert
+++ b/include/cassert
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- cassert -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ccomplex b/include/ccomplex
index 6ed116445..0d2e0f5a0 100644
--- a/include/ccomplex
+++ b/include/ccomplex
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- ccomplex ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cctype b/include/cctype
index 7fc813446..55fc9ebc6 100644
--- a/include/cctype
+++ b/include/cctype
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- cctype ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cerrno b/include/cerrno
index bab13b8aa..a9268a281 100644
--- a/include/cerrno
+++ b/include/cerrno
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- cerrno ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cfenv b/include/cfenv
index 4fc630419..6cd91db5a 100644
--- a/include/cfenv
+++ b/include/cfenv
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- cfenv -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cfloat b/include/cfloat
index 0abe84bf1..da22c6f60 100644
--- a/include/cfloat
+++ b/include/cfloat
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cfloat -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/charconv b/include/charconv
index 064f2e11c..ec9baa891 100644
--- a/include/charconv
+++ b/include/charconv
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ charconv ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/chrono b/include/chrono
index 96759f986..f7970647e 100644
--- a/include/chrono
+++ b/include/chrono
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- chrono ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ciso646 b/include/ciso646
index b2efc72a9..172f1676a 100644
--- a/include/ciso646
+++ b/include/ciso646
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- ciso646 ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/climits b/include/climits
index 81ffecdf6..43eb2d3f1 100644
--- a/include/climits
+++ b/include/climits
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- climits ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/clocale b/include/clocale
index 05fa9c6ed..bff4e92f9 100644
--- a/include/clocale
+++ b/include/clocale
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- clocale ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cmath b/include/cmath
index f5f62adcf..3af9f5481 100644
--- a/include/cmath
+++ b/include/cmath
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- cmath -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/codecvt b/include/codecvt
index 5eb9d1549..5ea411ea7 100644
--- a/include/codecvt
+++ b/include/codecvt
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- codecvt -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/compare b/include/compare
index 07f88f09c..e05257beb 100644
--- a/include/compare
+++ b/include/compare
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- compare -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/complex b/include/complex
index 8cf6a946d..ff702b4ff 100644
--- a/include/complex
+++ b/include/complex
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- complex ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/complex.h b/include/complex.h
index c2359665a..b78733b80 100644
--- a/include/complex.h
+++ b/include/complex.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- complex.h --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/condition_variable b/include/condition_variable
index c45a326d8..8c733448e 100644
--- a/include/condition_variable
+++ b/include/condition_variable
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------- condition_variable ----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/csetjmp b/include/csetjmp
index 58a9c73ab..ed94b50d1 100644
--- a/include/csetjmp
+++ b/include/csetjmp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- csetjmp ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/csignal b/include/csignal
index 972826618..99abd02de 100644
--- a/include/csignal
+++ b/include/csignal
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- csignal ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cstdarg b/include/cstdarg
index c8b699924..e8147d496 100644
--- a/include/cstdarg
+++ b/include/cstdarg
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cstdarg ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cstdbool b/include/cstdbool
index 2c764a61f..fad471414 100644
--- a/include/cstdbool
+++ b/include/cstdbool
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cstdbool ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cstddef b/include/cstddef
index b4c42b19d..bd62d6db3 100644
--- a/include/cstddef
+++ b/include/cstddef
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cstddef ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cstdint b/include/cstdint
index 7a187d3eb..f72fa0673 100644
--- a/include/cstdint
+++ b/include/cstdint
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cstdint ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cstdio b/include/cstdio
index 00b989fad..675569382 100644
--- a/include/cstdio
+++ b/include/cstdio
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- cstdio ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cstdlib b/include/cstdlib
index 00c604e67..68b3ded3f 100644
--- a/include/cstdlib
+++ b/include/cstdlib
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cstdlib ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ctgmath b/include/ctgmath
index 535eb7dcc..ba1eeeac9 100644
--- a/include/ctgmath
+++ b/include/ctgmath
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- ctgmath -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ctime b/include/ctime
index 8264fe33b..cb8474f8f 100644
--- a/include/ctime
+++ b/include/ctime
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- ctime -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ctype.h b/include/ctype.h
index e97ff3c48..dcc7935a2 100644
--- a/include/ctype.h
+++ b/include/ctype.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- ctype.h ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cwchar b/include/cwchar
index d268e8bbd..451c621f9 100644
--- a/include/cwchar
+++ b/include/cwchar
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cwchar -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/cwctype b/include/cwctype
index 25b2489ed..575fd5661 100644
--- a/include/cwctype
+++ b/include/cwctype
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- cwctype ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/deque b/include/deque
index 6f7d04be5..60a1130b2 100644
--- a/include/deque
+++ b/include/deque
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- deque -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/errno.h b/include/errno.h
index ee6429110..447319eff 100644
--- a/include/errno.h
+++ b/include/errno.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- errno.h -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/exception b/include/exception
index fdd83d10c..63d8ad229 100644
--- a/include/exception
+++ b/include/exception
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- exception ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/__config b/include/experimental/__config
index c6f177620..d3667b524 100644
--- a/include/experimental/__config
+++ b/include/experimental/__config
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- __config ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/__memory b/include/experimental/__memory
index 229fea605..4cf897846 100644
--- a/include/experimental/__memory
+++ b/include/experimental/__memory
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/algorithm b/include/experimental/algorithm
index eb3bad6ef..79fd7b1b2 100644
--- a/include/experimental/algorithm
+++ b/include/experimental/algorithm
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- algorithm ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/any b/include/experimental/any
index d9c953425..c8050e330 100644
--- a/include/experimental/any
+++ b/include/experimental/any
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------- any ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_ANY
diff --git a/include/experimental/chrono b/include/experimental/chrono
index 30c7e4a9d..f3ceaaea9 100644
--- a/include/experimental/chrono
+++ b/include/experimental/chrono
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- chrono ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_CHRONO
diff --git a/include/experimental/deque b/include/experimental/deque
index f8495743c..73c2787c7 100644
--- a/include/experimental/deque
+++ b/include/experimental/deque
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- deque ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/filesystem b/include/experimental/filesystem
index 28d8dcf4f..d2e6237df 100644
--- a/include/experimental/filesystem
+++ b/include/experimental/filesystem
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- filesystem -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_FILESYSTEM
diff --git a/include/experimental/forward_list b/include/experimental/forward_list
index 55e195f44..93f6debe9 100644
--- a/include/experimental/forward_list
+++ b/include/experimental/forward_list
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- forward_list -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/functional b/include/experimental/functional
index f63dfb07b..8c55f4f55 100644
--- a/include/experimental/functional
+++ b/include/experimental/functional
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- functional --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/list b/include/experimental/list
index 1678ee3e9..adc64a8b5 100644
--- a/include/experimental/list
+++ b/include/experimental/list
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- list ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/map b/include/experimental/map
index cff2c5e52..965d7582c 100644
--- a/include/experimental/map
+++ b/include/experimental/map
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- map ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/numeric b/include/experimental/numeric
index 19c65313f..4ea1306bf 100644
--- a/include/experimental/numeric
+++ b/include/experimental/numeric
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- numeric ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_NUMERIC
diff --git a/include/experimental/optional b/include/experimental/optional
index 6eb4a2618..1749cd6a6 100644
--- a/include/experimental/optional
+++ b/include/experimental/optional
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- optional ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_OPTIONAL
diff --git a/include/experimental/propagate_const b/include/experimental/propagate_const
index 188548596..092b013bb 100644
--- a/include/experimental/propagate_const
+++ b/include/experimental/propagate_const
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ propagate_const -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/ratio b/include/experimental/ratio
index 52c12004d..4cd4fa005 100644
--- a/include/experimental/ratio
+++ b/include/experimental/ratio
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- ratio ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_RATIO
diff --git a/include/experimental/regex b/include/experimental/regex
index d38891c37..17193cf2f 100644
--- a/include/experimental/regex
+++ b/include/experimental/regex
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- regex ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/set b/include/experimental/set
index 20cf6d4a3..52f4df384 100644
--- a/include/experimental/set
+++ b/include/experimental/set
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- list ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/simd b/include/experimental/simd
index 6580443f7..39ac35e4e 100644
--- a/include/experimental/simd
+++ b/include/experimental/simd
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------- simd ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_SIMD
diff --git a/include/experimental/string b/include/experimental/string
index 8b8545128..264ff9236 100644
--- a/include/experimental/string
+++ b/include/experimental/string
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- string ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/string_view b/include/experimental/string_view
index 100bdfe72..4b59e6d01 100644
--- a/include/experimental/string_view
+++ b/include/experimental/string_view
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ string_view ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_STRING_VIEW
diff --git a/include/experimental/system_error b/include/experimental/system_error
index 1cf84ee01..094e6d365 100644
--- a/include/experimental/system_error
+++ b/include/experimental/system_error
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- system_error ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
diff --git a/include/experimental/tuple b/include/experimental/tuple
index 6d71bb559..827ef37ae 100644
--- a/include/experimental/tuple
+++ b/include/experimental/tuple
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- tuple ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_EXPERIMENTAL_TUPLE
diff --git a/include/experimental/type_traits b/include/experimental/type_traits
index afe491567..3127c0ea9 100644
--- a/include/experimental/type_traits
+++ b/include/experimental/type_traits
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- type_traits -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/unordered_map b/include/experimental/unordered_map
index 1f998c2d4..eca9cea79 100644
--- a/include/experimental/unordered_map
+++ b/include/experimental/unordered_map
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- unordered_map ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/unordered_set b/include/experimental/unordered_set
index d00a83753..323868f78 100644
--- a/include/experimental/unordered_set
+++ b/include/experimental/unordered_set
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- unordered_set ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/utility b/include/experimental/utility
index 8effa71c1..0bca0f7c9 100644
--- a/include/experimental/utility
+++ b/include/experimental/utility
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- utility ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/experimental/vector b/include/experimental/vector
index bd10492bf..9b8101206 100644
--- a/include/experimental/vector
+++ b/include/experimental/vector
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- vector ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ext/__hash b/include/ext/__hash
index 318cb1f97..98a954483 100644
--- a/include/ext/__hash
+++ b/include/ext/__hash
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- hash_set ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ext/hash_map b/include/ext/hash_map
index 998e8f659..d06a9e36a 100644
--- a/include/ext/hash_map
+++ b/include/ext/hash_map
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- hash_map ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ext/hash_set b/include/ext/hash_set
index 38f81ed3b..21e66877c 100644
--- a/include/ext/hash_set
+++ b/include/ext/hash_set
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- hash_set ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/filesystem b/include/filesystem
index af713a063..6b33ffda7 100644
--- a/include/filesystem
+++ b/include/filesystem
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- filesystem -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_FILESYSTEM
diff --git a/include/float.h b/include/float.h
index 759ac8e79..5c1e1db79 100644
--- a/include/float.h
+++ b/include/float.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- float.h ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/forward_list b/include/forward_list
index b506acd1f..bbea71ee1 100644
--- a/include/forward_list
+++ b/include/forward_list
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------- forward_list ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/fstream b/include/fstream
index 711e484e2..1902ce9af 100644
--- a/include/fstream
+++ b/include/fstream
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- fstream ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/functional b/include/functional
index 95491879b..086610e61 100644
--- a/include/functional
+++ b/include/functional
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ functional ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/future b/include/future
index b3ffc7e35..50bdd2da2 100644
--- a/include/future
+++ b/include/future
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- future -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/initializer_list b/include/initializer_list
index b934637b8..6c4493b70 100644
--- a/include/initializer_list
+++ b/include/initializer_list
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------- initializer_list -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/iomanip b/include/iomanip
index 36c11167a..82b7603a3 100644
--- a/include/iomanip
+++ b/include/iomanip
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- iomanip ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ios b/include/ios
index 040b2d4e0..963363963 100644
--- a/include/ios
+++ b/include/ios
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- ios -------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/iosfwd b/include/iosfwd
index 31f1902e5..0ffe75f19 100644
--- a/include/iosfwd
+++ b/include/iosfwd
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- iosfwd -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/iostream b/include/iostream
index 136a84977..595620b8a 100644
--- a/include/iostream
+++ b/include/iostream
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- iostream ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/istream b/include/istream
index 30ee4f4b8..bedd738f1 100644
--- a/include/istream
+++ b/include/istream
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- istream ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/iterator b/include/iterator
index bda177e11..242f18814 100644
--- a/include/iterator
+++ b/include/iterator
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- iterator ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/limits b/include/limits
index 5ea9a9e6f..82c1ea133 100644
--- a/include/limits
+++ b/include/limits
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- limits ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/limits.h b/include/limits.h
index 1867b1048..4a212f8f3 100644
--- a/include/limits.h
+++ b/include/limits.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- limits.h ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/list b/include/list
index c69e31d93..2afe2a205 100644
--- a/include/list
+++ b/include/list
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- list ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/locale b/include/locale
index 2043892fa..f16d4ba1f 100644
--- a/include/locale
+++ b/include/locale
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- locale ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/locale.h b/include/locale.h
index cad7b8b53..a21ee385c 100644
--- a/include/locale.h
+++ b/include/locale.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- locale.h --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/map b/include/map
index 616bb46cf..47f5c678b 100644
--- a/include/map
+++ b/include/map
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- map ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/math.h b/include/math.h
index 3cc72aa27..6f9a76ba9 100644
--- a/include/math.h
+++ b/include/math.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- math.h ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/memory b/include/memory
index ce2c35766..3398629c1 100644
--- a/include/memory
+++ b/include/memory
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- memory ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/mutex b/include/mutex
index 6d2de2b46..98bd581eb 100644
--- a/include/mutex
+++ b/include/mutex
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- mutex ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/new b/include/new
index 24ffcad5a..b5e8fb412 100644
--- a/include/new
+++ b/include/new
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------- new ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/numeric b/include/numeric
index 4e68239d0..99417703e 100644
--- a/include/numeric
+++ b/include/numeric
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- numeric ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/optional b/include/optional
index 70422068e..be584b3ce 100644
--- a/include/optional
+++ b/include/optional
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- optional ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ostream b/include/ostream
index d700a369b..b20ac34a3 100644
--- a/include/ostream
+++ b/include/ostream
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- ostream -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/queue b/include/queue
index 4677e52ae..55be80017 100644
--- a/include/queue
+++ b/include/queue
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- queue ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/random b/include/random
index 724bd0fc2..a73239519 100644
--- a/include/random
+++ b/include/random
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- random -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/ratio b/include/ratio
index 7ee5ec245..fa7a4bbb2 100644
--- a/include/ratio
+++ b/include/ratio
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- ratio -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/regex b/include/regex
index bd83d7c10..d47978037 100644
--- a/include/regex
+++ b/include/regex
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- regex ------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/scoped_allocator b/include/scoped_allocator
index bdbb0136b..237cd428d 100644
--- a/include/scoped_allocator
+++ b/include/scoped_allocator
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- scoped_allocator --------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/set b/include/set
index a0155f0b2..17837228f 100644
--- a/include/set
+++ b/include/set
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- set -------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/setjmp.h b/include/setjmp.h
index 464b4a540..f30a8d401 100644
--- a/include/setjmp.h
+++ b/include/setjmp.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- setjmp.h ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/shared_mutex b/include/shared_mutex
index 3daf74d26..fcafd8c0f 100644
--- a/include/shared_mutex
+++ b/include/shared_mutex
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ shared_mutex --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/span b/include/span
index cebe98760..774f69823 100644
--- a/include/span
+++ b/include/span
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 
diff --git a/include/sstream b/include/sstream
index 9c3ee13bf..71204e0fa 100644
--- a/include/sstream
+++ b/include/sstream
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- sstream ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/stack b/include/stack
index 2b3f8aea1..b50ca5cdc 100644
--- a/include/stack
+++ b/include/stack
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- stack -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/stdbool.h b/include/stdbool.h
index 86a127f0f..81a7cb303 100644
--- a/include/stdbool.h
+++ b/include/stdbool.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- stdbool.h --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_STDBOOL_H
diff --git a/include/stddef.h b/include/stddef.h
index f65065d86..6497dcda2 100644
--- a/include/stddef.h
+++ b/include/stddef.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- stddef.h ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/stdexcept b/include/stdexcept
index 3ec79349a..6eda619b8 100644
--- a/include/stdexcept
+++ b/include/stdexcept
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- stdexcept --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/stdio.h b/include/stdio.h
index 77a314bf3..e08e6bc9b 100644
--- a/include/stdio.h
+++ b/include/stdio.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- stdio.h ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/stdlib.h b/include/stdlib.h
index f11c5e762..2087544de 100644
--- a/include/stdlib.h
+++ b/include/stdlib.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- stdlib.h ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/streambuf b/include/streambuf
index dd293dc63..48c07d5e1 100644
--- a/include/streambuf
+++ b/include/streambuf
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------- streambuf ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/strstream b/include/strstream
index b00b9d830..31999bbae 100644
--- a/include/strstream
+++ b/include/strstream
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- strstream --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/android/locale_bionic.h b/include/support/android/locale_bionic.h
index 50fcf5c36..5b16071d9 100644
--- a/include/support/android/locale_bionic.h
+++ b/include/support/android/locale_bionic.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------- support/android/locale_bionic.h ------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/fuchsia/xlocale.h b/include/support/fuchsia/xlocale.h
index 1de2fca28..b86ce9efb 100644
--- a/include/support/fuchsia/xlocale.h
+++ b/include/support/fuchsia/xlocale.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------- support/fuchsia/xlocale.h ------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/ibm/limits.h b/include/support/ibm/limits.h
index efdb35965..d1c59f066 100644
--- a/include/support/ibm/limits.h
+++ b/include/support/ibm/limits.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------- support/ibm/limits.h ---------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/ibm/locale_mgmt_aix.h b/include/support/ibm/locale_mgmt_aix.h
index e3b7a78c4..e452dc325 100644
--- a/include/support/ibm/locale_mgmt_aix.h
+++ b/include/support/ibm/locale_mgmt_aix.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------- support/ibm/locale_mgmt_aix.h --------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/ibm/support.h b/include/support/ibm/support.h
index 0abfa7f95..0569cbe74 100644
--- a/include/support/ibm/support.h
+++ b/include/support/ibm/support.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------- support/ibm/support.h ----------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/ibm/xlocale.h b/include/support/ibm/xlocale.h
index f39c0ba95..9f0522c19 100644
--- a/include/support/ibm/xlocale.h
+++ b/include/support/ibm/xlocale.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------- support/ibm/xlocale.h -------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/musl/xlocale.h b/include/support/musl/xlocale.h
index 3e31c9959..722d13fa1 100644
--- a/include/support/musl/xlocale.h
+++ b/include/support/musl/xlocale.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------- support/musl/xlocale.h ------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // This adds support for the extended locale functions that are currently
diff --git a/include/support/newlib/xlocale.h b/include/support/newlib/xlocale.h
index 09f9e3987..25fa798b6 100644
--- a/include/support/newlib/xlocale.h
+++ b/include/support/newlib/xlocale.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/solaris/floatingpoint.h b/include/support/solaris/floatingpoint.h
index 999d144b1..5f1628fbe 100644
--- a/include/support/solaris/floatingpoint.h
+++ b/include/support/solaris/floatingpoint.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/solaris/wchar.h b/include/support/solaris/wchar.h
index 0e8e660c8..9dc9ac3f0 100644
--- a/include/support/solaris/wchar.h
+++ b/include/support/solaris/wchar.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/solaris/xlocale.h b/include/support/solaris/xlocale.h
index e20ef7a6e..05131f027 100644
--- a/include/support/solaris/xlocale.h
+++ b/include/support/solaris/xlocale.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/win32/limits_msvc_win32.h b/include/support/win32/limits_msvc_win32.h
index 1ab2e0b6d..7bb835559 100644
--- a/include/support/win32/limits_msvc_win32.h
+++ b/include/support/win32/limits_msvc_win32.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------ support/win32/limits_msvc_win32.h -----------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/win32/locale_win32.h b/include/support/win32/locale_win32.h
index c7c6d786c..0d03d834b 100644
--- a/include/support/win32/locale_win32.h
+++ b/include/support/win32/locale_win32.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------- support/win32/locale_win32.h -------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/xlocale/__nop_locale_mgmt.h b/include/support/xlocale/__nop_locale_mgmt.h
index 0d3f23a2c..f33d3894c 100644
--- a/include/support/xlocale/__nop_locale_mgmt.h
+++ b/include/support/xlocale/__nop_locale_mgmt.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------  support/xlocale/__nop_locale_mgmt.h -----------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/support/xlocale/__posix_l_fallback.h b/include/support/xlocale/__posix_l_fallback.h
index b9a0939f8..f3df6c46f 100644
--- a/include/support/xlocale/__posix_l_fallback.h
+++ b/include/support/xlocale/__posix_l_fallback.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------- support/xlocale/__posix_l_fallback.h -----------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // These are reimplementations of some extended locale functions ( *_l ) that
diff --git a/include/support/xlocale/__strtonum_fallback.h b/include/support/xlocale/__strtonum_fallback.h
index 50b4db354..df3859805 100644
--- a/include/support/xlocale/__strtonum_fallback.h
+++ b/include/support/xlocale/__strtonum_fallback.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------- support/xlocale/__strtonum_fallback.h -----------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // These are reimplementations of some extended locale functions ( *_l ) that
diff --git a/include/system_error b/include/system_error
index 6e2c8388f..05ef07950 100644
--- a/include/system_error
+++ b/include/system_error
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- system_error ----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/tgmath.h b/include/tgmath.h
index aba87499c..2dc1f771d 100644
--- a/include/tgmath.h
+++ b/include/tgmath.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- tgmath.h ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/thread b/include/thread
index 8c0115f87..df06ff70f 100644
--- a/include/thread
+++ b/include/thread
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- thread -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/type_traits b/include/type_traits
index 8b30511a4..52a46adc5 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ type_traits ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/typeindex b/include/typeindex
index 0565ca913..bff1e65af 100644
--- a/include/typeindex
+++ b/include/typeindex
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- typeindex ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/typeinfo b/include/typeinfo
index 841153286..451d9c950 100644
--- a/include/typeinfo
+++ b/include/typeinfo
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- typeinfo ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/unordered_map b/include/unordered_map
index 6035b05dc..87278b07d 100644
--- a/include/unordered_map
+++ b/include/unordered_map
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- unordered_map -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/unordered_set b/include/unordered_set
index b4e61da89..4cfaa86b8 100644
--- a/include/unordered_set
+++ b/include/unordered_set
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- unordered_set -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/utility b/include/utility
index 74bbc5cf3..770d160f2 100644
--- a/include/utility
+++ b/include/utility
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- utility -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/valarray b/include/valarray
index 07f38c811..c9ca08c61 100644
--- a/include/valarray
+++ b/include/valarray
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- valarray ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/variant b/include/variant
index a4339de6c..5d0722b62 100644
--- a/include/variant
+++ b/include/variant
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ variant -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/vector b/include/vector
index edb6d3e09..79d17675a 100644
--- a/include/vector
+++ b/include/vector
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ vector --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/version b/include/version
index e37afc448..1037ee5df 100644
--- a/include/version
+++ b/include/version
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- version ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/wchar.h b/include/wchar.h
index f74fe6ddc..353c979d2 100644
--- a/include/wchar.h
+++ b/include/wchar.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- wchar.h ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/wctype.h b/include/wctype.h
index f9c5a4775..bdcf37234 100644
--- a/include/wctype.h
+++ b/include/wctype.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- wctype.h ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/algorithm.cpp b/src/algorithm.cpp
index f036eb7ab..28e452f52 100644
--- a/src/algorithm.cpp
+++ b/src/algorithm.cpp
@@ -1,9 +1,8 @@
 //===----------------------- algorithm.cpp --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/any.cpp b/src/any.cpp
index 3795258bb..0cf090688 100644
--- a/src/any.cpp
+++ b/src/any.cpp
@@ -1,9 +1,8 @@
 //===---------------------------- any.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/bind.cpp b/src/bind.cpp
index b4c76ffe6..53efdf9df 100644
--- a/src/bind.cpp
+++ b/src/bind.cpp
@@ -1,9 +1,8 @@
 //===-------------------------- bind.cpp ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/charconv.cpp b/src/charconv.cpp
index ec241db74..6ea473b25 100644
--- a/src/charconv.cpp
+++ b/src/charconv.cpp
@@ -1,9 +1,8 @@
 //===------------------------- charconv.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/chrono.cpp b/src/chrono.cpp
index 882d50b9d..ea0a638ac 100644
--- a/src/chrono.cpp
+++ b/src/chrono.cpp
@@ -1,9 +1,8 @@
 //===------------------------- chrono.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/condition_variable.cpp b/src/condition_variable.cpp
index 2200aefb8..4022ff2e9 100644
--- a/src/condition_variable.cpp
+++ b/src/condition_variable.cpp
@@ -1,9 +1,8 @@
 //===-------------------- condition_variable.cpp --------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/debug.cpp b/src/debug.cpp
index f2fc1ceb4..2e88b859b 100644
--- a/src/debug.cpp
+++ b/src/debug.cpp
@@ -1,9 +1,8 @@
 //===-------------------------- debug.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/exception.cpp b/src/exception.cpp
index 3d2dcfd5b..ee9f384b6 100644
--- a/src/exception.cpp
+++ b/src/exception.cpp
@@ -1,9 +1,8 @@
 //===------------------------ exception.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/experimental/memory_resource.cpp b/src/experimental/memory_resource.cpp
index 7f0052f2b..977ee2b56 100644
--- a/src/experimental/memory_resource.cpp
+++ b/src/experimental/memory_resource.cpp
@@ -1,9 +1,8 @@
 //===------------------------ memory_resource.cpp -------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/filesystem/directory_iterator.cpp b/src/filesystem/directory_iterator.cpp
index f0d807a03..edecf69ef 100644
--- a/src/filesystem/directory_iterator.cpp
+++ b/src/filesystem/directory_iterator.cpp
@@ -1,9 +1,8 @@
 //===------------------ directory_iterator.cpp ----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/filesystem/filesystem_common.h b/src/filesystem/filesystem_common.h
index 40419ee35..fe5c42f5e 100644
--- a/src/filesystem/filesystem_common.h
+++ b/src/filesystem/filesystem_common.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===////
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===////
 
diff --git a/src/filesystem/int128_builtins.cpp b/src/filesystem/int128_builtins.cpp
index 66adbdd2d..a55540fe2 100644
--- a/src/filesystem/int128_builtins.cpp
+++ b/src/filesystem/int128_builtins.cpp
@@ -1,9 +1,8 @@
 /*===-- int128_builtins.cpp - Implement __muloti4 --------------------------===
  *
- *                     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.
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  * ===----------------------------------------------------------------------===
  *
diff --git a/src/filesystem/operations.cpp b/src/filesystem/operations.cpp
index 54a234e5f..5ba979ca9 100644
--- a/src/filesystem/operations.cpp
+++ b/src/filesystem/operations.cpp
@@ -1,9 +1,8 @@
 //===--------------------- filesystem/ops.cpp -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/functional.cpp b/src/functional.cpp
index 5c2646f01..555d2c53f 100644
--- a/src/functional.cpp
+++ b/src/functional.cpp
@@ -1,9 +1,8 @@
 //===----------------------- functional.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/future.cpp b/src/future.cpp
index cbcd2e7b7..58d0b4c24 100644
--- a/src/future.cpp
+++ b/src/future.cpp
@@ -1,9 +1,8 @@
 //===------------------------- future.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/hash.cpp b/src/hash.cpp
index dc90f789c..1631b91ac 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -1,9 +1,8 @@
 //===-------------------------- hash.cpp ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/include/apple_availability.h b/src/include/apple_availability.h
index c12f7325c..009113817 100644
--- a/src/include/apple_availability.h
+++ b/src/include/apple_availability.h
@@ -1,9 +1,8 @@
 //===------------------------ apple_availability.h ------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
diff --git a/src/include/atomic_support.h b/src/include/atomic_support.h
index ccd8d78d3..43c1a0023 100644
--- a/src/include/atomic_support.h
+++ b/src/include/atomic_support.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===////
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===////
 
diff --git a/src/include/config_elast.h b/src/include/config_elast.h
index c3cc19c22..18391afa0 100644
--- a/src/include/config_elast.h
+++ b/src/include/config_elast.h
@@ -1,9 +1,8 @@
 //===----------------------- config_elast.h -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/include/refstring.h b/src/include/refstring.h
index 702f2b738..e464b79ba 100644
--- a/src/include/refstring.h
+++ b/src/include/refstring.h
@@ -1,9 +1,8 @@
 //===------------------------ __refstring ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/ios.cpp b/src/ios.cpp
index 0f1d88e37..fdff2e8fe 100644
--- a/src/ios.cpp
+++ b/src/ios.cpp
@@ -1,9 +1,8 @@
 //===-------------------------- ios.cpp -----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/iostream.cpp b/src/iostream.cpp
index 11bfb4862..9b8d1fa44 100644
--- a/src/iostream.cpp
+++ b/src/iostream.cpp
@@ -1,9 +1,8 @@
 //===------------------------ iostream.cpp --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/locale.cpp b/src/locale.cpp
index b9c701137..18edad73f 100644
--- a/src/locale.cpp
+++ b/src/locale.cpp
@@ -1,9 +1,8 @@
 //===------------------------- locale.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/memory.cpp b/src/memory.cpp
index 77ebe837c..8b05c3f16 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -1,9 +1,8 @@
 //===------------------------ memory.cpp ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/mutex.cpp b/src/mutex.cpp
index c61d34bb8..a9ccc9aa9 100644
--- a/src/mutex.cpp
+++ b/src/mutex.cpp
@@ -1,9 +1,8 @@
 //===------------------------- mutex.cpp ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/new.cpp b/src/new.cpp
index cc8383d4f..eb5ce75f1 100644
--- a/src/new.cpp
+++ b/src/new.cpp
@@ -1,9 +1,8 @@
 //===--------------------------- new.cpp ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/optional.cpp b/src/optional.cpp
index 6099b6b41..3aaf5ea55 100644
--- a/src/optional.cpp
+++ b/src/optional.cpp
@@ -1,9 +1,8 @@
 //===------------------------ optional.cpp --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/random.cpp b/src/random.cpp
index 4a2468368..04adc59f9 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -1,9 +1,8 @@
 //===-------------------------- random.cpp --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/regex.cpp b/src/regex.cpp
index a7363599d..a971f6464 100644
--- a/src/regex.cpp
+++ b/src/regex.cpp
@@ -1,9 +1,8 @@
 //===-------------------------- regex.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/shared_mutex.cpp b/src/shared_mutex.cpp
index 6185f15de..e918e1bdf 100644
--- a/src/shared_mutex.cpp
+++ b/src/shared_mutex.cpp
@@ -1,9 +1,8 @@
 //===---------------------- shared_mutex.cpp ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/stdexcept.cpp b/src/stdexcept.cpp
index 5e06e521e..6ae35feed 100644
--- a/src/stdexcept.cpp
+++ b/src/stdexcept.cpp
@@ -1,9 +1,8 @@
 //===------------------------ stdexcept.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/string.cpp b/src/string.cpp
index d7ebdd3e5..6c89a5d7e 100644
--- a/src/string.cpp
+++ b/src/string.cpp
@@ -1,9 +1,8 @@
 //===------------------------- string.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/strstream.cpp b/src/strstream.cpp
index 8b8521f76..ae6680683 100644
--- a/src/strstream.cpp
+++ b/src/strstream.cpp
@@ -1,9 +1,8 @@
 //===------------------------ strstream.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_fallback.ipp b/src/support/runtime/exception_fallback.ipp
index 16d387b99..376a0381f 100644
--- a/src/support/runtime/exception_fallback.ipp
+++ b/src/support/runtime/exception_fallback.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_glibcxx.ipp b/src/support/runtime/exception_glibcxx.ipp
index dda4432b5..4bf3c4d87 100644
--- a/src/support/runtime/exception_glibcxx.ipp
+++ b/src/support/runtime/exception_glibcxx.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_libcxxabi.ipp b/src/support/runtime/exception_libcxxabi.ipp
index feefc5152..6bc049bf3 100644
--- a/src/support/runtime/exception_libcxxabi.ipp
+++ b/src/support/runtime/exception_libcxxabi.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_libcxxrt.ipp b/src/support/runtime/exception_libcxxrt.ipp
index 52fe8635d..0ebffdedb 100644
--- a/src/support/runtime/exception_libcxxrt.ipp
+++ b/src/support/runtime/exception_libcxxrt.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_msvc.ipp b/src/support/runtime/exception_msvc.ipp
index 042d3add6..21119b0e9 100644
--- a/src/support/runtime/exception_msvc.ipp
+++ b/src/support/runtime/exception_msvc.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_pointer_cxxabi.ipp b/src/support/runtime/exception_pointer_cxxabi.ipp
index dfac8648c..82a8e6972 100644
--- a/src/support/runtime/exception_pointer_cxxabi.ipp
+++ b/src/support/runtime/exception_pointer_cxxabi.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_pointer_glibcxx.ipp b/src/support/runtime/exception_pointer_glibcxx.ipp
index 9d20dfe48..3abc137c6 100644
--- a/src/support/runtime/exception_pointer_glibcxx.ipp
+++ b/src/support/runtime/exception_pointer_glibcxx.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_pointer_msvc.ipp b/src/support/runtime/exception_pointer_msvc.ipp
index 9b0d2361e..b1a369522 100644
--- a/src/support/runtime/exception_pointer_msvc.ipp
+++ b/src/support/runtime/exception_pointer_msvc.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/exception_pointer_unimplemented.ipp b/src/support/runtime/exception_pointer_unimplemented.ipp
index 21c182c85..991bca9ec 100644
--- a/src/support/runtime/exception_pointer_unimplemented.ipp
+++ b/src/support/runtime/exception_pointer_unimplemented.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/runtime/new_handler_fallback.ipp b/src/support/runtime/new_handler_fallback.ipp
index ec3f52354..720509394 100644
--- a/src/support/runtime/new_handler_fallback.ipp
+++ b/src/support/runtime/new_handler_fallback.ipp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/solaris/xlocale.cpp b/src/support/solaris/xlocale.cpp
index 6eaf317c7..b6a2bfe21 100644
--- a/src/support/solaris/xlocale.cpp
+++ b/src/support/solaris/xlocale.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/win32/locale_win32.cpp b/src/support/win32/locale_win32.cpp
index cad9d4e81..c11adfe4c 100644
--- a/src/support/win32/locale_win32.cpp
+++ b/src/support/win32/locale_win32.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------- support/win32/locale_win32.cpp ------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/win32/support.cpp b/src/support/win32/support.cpp
index aa636fba5..b4f1e22f3 100644
--- a/src/support/win32/support.cpp
+++ b/src/support/win32/support.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------- support/win32/support.h ----------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/support/win32/thread_win32.cpp b/src/support/win32/thread_win32.cpp
index 1567042d8..3ca36df80 100644
--- a/src/support/win32/thread_win32.cpp
+++ b/src/support/win32/thread_win32.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------- support/win32/thread_win32.cpp ------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/system_error.cpp b/src/system_error.cpp
index 06caa6fec..9ddf7bcbe 100644
--- a/src/system_error.cpp
+++ b/src/system_error.cpp
@@ -1,9 +1,8 @@
 //===---------------------- system_error.cpp ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/thread.cpp b/src/thread.cpp
index 241cfee23..bc5dfb243 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -1,9 +1,8 @@
 //===------------------------- thread.cpp----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/typeinfo.cpp b/src/typeinfo.cpp
index 42ff9351e..b49c98273 100644
--- a/src/typeinfo.cpp
+++ b/src/typeinfo.cpp
@@ -1,9 +1,8 @@
 //===------------------------- typeinfo.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/utility.cpp b/src/utility.cpp
index 7dccffb73..016a5d91b 100644
--- a/src/utility.cpp
+++ b/src/utility.cpp
@@ -1,9 +1,8 @@
 //===------------------------ utility.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/valarray.cpp b/src/valarray.cpp
index 2d8db52ac..893de050f 100644
--- a/src/valarray.cpp
+++ b/src/valarray.cpp
@@ -1,9 +1,8 @@
 //===------------------------ valarray.cpp --------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/variant.cpp b/src/variant.cpp
index 5bb508c3f..1fe70a180 100644
--- a/src/variant.cpp
+++ b/src/variant.cpp
@@ -1,9 +1,8 @@
 //===------------------------ variant.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/src/vector.cpp b/src/vector.cpp
index 300adaed5..3b65e558f 100644
--- a/src/vector.cpp
+++ b/src/vector.cpp
@@ -1,9 +1,8 @@
 //===------------------------- vector.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
index 58ce68998..926ee40f0 100644
--- a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
+++ b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
index 608f4f86c..aca87ffb3 100644
--- a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
+++ b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/algorithms/debug_less.pass.cpp b/test/libcxx/algorithms/debug_less.pass.cpp
index 302c5a837..f5b2796fd 100644
--- a/test/libcxx/algorithms/debug_less.pass.cpp
+++ b/test/libcxx/algorithms/debug_less.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/algorithms/half_positive.pass.cpp b/test/libcxx/algorithms/half_positive.pass.cpp
index 7dcfc2c92..1434b3e9a 100644
--- a/test/libcxx/algorithms/half_positive.pass.cpp
+++ b/test/libcxx/algorithms/half_positive.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/algorithms/version.pass.cpp b/test/libcxx/algorithms/version.pass.cpp
index 20f0637e6..4fcd03674 100644
--- a/test/libcxx/algorithms/version.pass.cpp
+++ b/test/libcxx/algorithms/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/atomics/atomics.align/align.pass.sh.cpp b/test/libcxx/atomics/atomics.align/align.pass.sh.cpp
index e0ae37e9c..7162493c5 100644
--- a/test/libcxx/atomics/atomics.align/align.pass.sh.cpp
+++ b/test/libcxx/atomics/atomics.align/align.pass.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp b/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
index 9dd68bd4e..7006a86d4 100644
--- a/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
+++ b/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp b/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
index 51a1f2307..2869bf96e 100644
--- a/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
+++ b/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp b/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
index 38f89db17..27ae20929 100644
--- a/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
+++ b/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp b/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
index e587e6b43..41fbe2879 100644
--- a/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
+++ b/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // XFAIL: libcpp-has-no-threads
diff --git a/test/libcxx/atomics/version.pass.cpp b/test/libcxx/atomics/version.pass.cpp
index fae2736d2..5d89bc575 100644
--- a/test/libcxx/atomics/version.pass.cpp
+++ b/test/libcxx/atomics/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/containers/associative/map/version.pass.cpp b/test/libcxx/containers/associative/map/version.pass.cpp
index b2e3fa43e..da33a03de 100644
--- a/test/libcxx/containers/associative/map/version.pass.cpp
+++ b/test/libcxx/containers/associative/map/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/non_const_comparator.fail.cpp b/test/libcxx/containers/associative/non_const_comparator.fail.cpp
index ddd796089..23c6ee8a2 100644
--- a/test/libcxx/containers/associative/non_const_comparator.fail.cpp
+++ b/test/libcxx/containers/associative/non_const_comparator.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/set/version.pass.cpp b/test/libcxx/containers/associative/set/version.pass.cpp
index c3c4d926e..57420bae4 100644
--- a/test/libcxx/containers/associative/set/version.pass.cpp
+++ b/test/libcxx/containers/associative/set/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp b/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
index 300c1e9a4..8f17dbba7 100644
--- a/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
+++ b/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp b/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
index 0befd749a..3b5ba7d2a 100644
--- a/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
+++ b/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/tree_left_rotate.pass.cpp b/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
index 2720b448b..c7f136c8c 100644
--- a/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
+++ b/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/tree_remove.pass.cpp b/test/libcxx/containers/associative/tree_remove.pass.cpp
index fa0b7d4a1..b2c814dd7 100644
--- a/test/libcxx/containers/associative/tree_remove.pass.cpp
+++ b/test/libcxx/containers/associative/tree_remove.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/tree_right_rotate.pass.cpp b/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
index 9355a46b4..bcaf71f0b 100644
--- a/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
+++ b/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/associative/undef_min_max.pass.cpp b/test/libcxx/containers/associative/undef_min_max.pass.cpp
index be5e11052..8ebd8a4ae 100644
--- a/test/libcxx/containers/associative/undef_min_max.pass.cpp
+++ b/test/libcxx/containers/associative/undef_min_max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/container.adaptors/queue/version.pass.cpp b/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
index 35b94b33c..87d907a5a 100644
--- a/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
+++ b/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/container.adaptors/stack/version.pass.cpp b/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
index 339d0f4dd..00ed12c06 100644
--- a/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
+++ b/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp b/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
index 0d9115d0f..9470a9e31 100644
--- a/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
+++ b/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp b/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
index 5fd4bde66..cd6cfeb0a 100644
--- a/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
+++ b/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp b/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
index 465523f84..3f1084c47 100644
--- a/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
+++ b/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp b/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
index d49b3a763..6fd053dd6 100644
--- a/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
+++ b/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp b/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
index 4d6ad6907..fadc22810 100644
--- a/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
+++ b/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/array/version.pass.cpp b/test/libcxx/containers/sequences/array/version.pass.cpp
index b89a8dd8c..21eb25764 100644
--- a/test/libcxx/containers/sequences/array/version.pass.cpp
+++ b/test/libcxx/containers/sequences/array/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/deque/incomplete.pass.cpp b/test/libcxx/containers/sequences/deque/incomplete.pass.cpp
index c23195ed2..3c5528d28 100644
--- a/test/libcxx/containers/sequences/deque/incomplete.pass.cpp
+++ b/test/libcxx/containers/sequences/deque/incomplete.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp b/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
index e4f5d0b01..2b87e53b9 100644
--- a/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
+++ b/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/deque/version.pass.cpp b/test/libcxx/containers/sequences/deque/version.pass.cpp
index 22e663d9b..12256878a 100644
--- a/test/libcxx/containers/sequences/deque/version.pass.cpp
+++ b/test/libcxx/containers/sequences/deque/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/forwardlist/version.pass.cpp b/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
index 918c8dd5d..7e61bde5c 100644
--- a/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
+++ b/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp b/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
index a0b35f335..62695f8f8 100644
--- a/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp b/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
index 570e5a0b3..02306eb88 100644
--- a/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
index 67146bc7c..9554fd8bc 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
index 24cadbe01..6fa81ff47 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
index 6d3e7617b..45d163a99 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
index dd592f90c..5553221c1 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
index d5e8fd9d8..4ebe93b94 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
index 3ae20cdc5..a89ee5645 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
index 6d6e29e47..60f9cf2e5 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
index 03b9667cf..d3370b5de 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
index 6e25b0c3c..d51658473 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
index 6999c4053..5bd20f7b6 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
index 66983f01e..174425091 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
index 9151fc1dd..4a292ff1f 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
index 541dd056b..71882fd14 100644
--- a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
index 64ef78ed0..cfaf10b51 100644
--- a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
index 9fed4b577..9f48a7089 100644
--- a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/list/version.pass.cpp b/test/libcxx/containers/sequences/list/version.pass.cpp
index 097c013f5..92a1988cf 100644
--- a/test/libcxx/containers/sequences/list/version.pass.cpp
+++ b/test/libcxx/containers/sequences/list/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/asan.pass.cpp b/test/libcxx/containers/sequences/vector/asan.pass.cpp
index db337e6b2..bf29d9b14 100644
--- a/test/libcxx/containers/sequences/vector/asan.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/asan.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp b/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
index 30cf3f42e..ce07bf778 100644
--- a/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp b/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
index 2a150f7cc..ffe8ca4ca 100644
--- a/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_back.pass.cpp b/test/libcxx/containers/sequences/vector/db_back.pass.cpp
index d66ffeb67..21f19a9ec 100644
--- a/test/libcxx/containers/sequences/vector/db_back.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_cback.pass.cpp b/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
index 9ad0fb929..cc1a3d253 100644
--- a/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp b/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
index 58f57a500..83d9c00b2 100644
--- a/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp b/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
index 9a54b6cb9..fc808eeb9 100644
--- a/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_front.pass.cpp b/test/libcxx/containers/sequences/vector/db_front.pass.cpp
index 0acb7df0c..df7bd35e0 100644
--- a/test/libcxx/containers/sequences/vector/db_front.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_index.pass.cpp b/test/libcxx/containers/sequences/vector/db_index.pass.cpp
index 75ae095f2..5cb192548 100644
--- a/test/libcxx/containers/sequences/vector/db_index.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
index d5e8c8610..d7222dd18 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
index 96a75204a..d39d99c3c 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
index 311a517cf..f868b755e 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
index 6df3fd459..c5039f9f8 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
index 0785dd964..ff60a05a4 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
index 11ba9f864..8249fd752 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
index 0434ad5f1..c619f20dd 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp b/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
index 388dfa4e1..0ce185325 100644
--- a/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index 998d0b74e..ee139c188 100644
--- a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
index c4950fbe6..37814b2f1 100644
--- a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/sequences/vector/version.pass.cpp b/test/libcxx/containers/sequences/vector/version.pass.cpp
index 2c4fa1263..16f45fc0b 100644
--- a/test/libcxx/containers/sequences/vector/version.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/key_value_traits.pass.cpp b/test/libcxx/containers/unord/key_value_traits.pass.cpp
index a6d1ea7a5..c2d754b11 100644
--- a/test/libcxx/containers/unord/key_value_traits.pass.cpp
+++ b/test/libcxx/containers/unord/key_value_traits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/next_pow2.pass.cpp b/test/libcxx/containers/unord/next_pow2.pass.cpp
index a878da4f5..36229dc24 100644
--- a/test/libcxx/containers/unord/next_pow2.pass.cpp
+++ b/test/libcxx/containers/unord/next_pow2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/containers/unord/next_prime.pass.cpp b/test/libcxx/containers/unord/next_prime.pass.cpp
index 266d7f1f9..e049e451a 100644
--- a/test/libcxx/containers/unord/next_prime.pass.cpp
+++ b/test/libcxx/containers/unord/next_prime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/containers/unord/non_const_comparator.fail.cpp b/test/libcxx/containers/unord/non_const_comparator.fail.cpp
index f428ab9ac..15fb8d4ed 100644
--- a/test/libcxx/containers/unord/non_const_comparator.fail.cpp
+++ b/test/libcxx/containers/unord/non_const_comparator.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp b/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
index 664cb7e86..0206b998c 100644
--- a/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp b/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
index 621d7f343..79ddccd1f 100644
--- a/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp b/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
index 19794e047..002dcd31a 100644
--- a/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp b/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
index 1567caf9b..887093b3c 100644
--- a/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/unord.map/version.pass.cpp b/test/libcxx/containers/unord/unord.map/version.pass.cpp
index fc47a326c..ce4a2784c 100644
--- a/test/libcxx/containers/unord/unord.map/version.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp b/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
index d6554a63c..9ef240df8 100644
--- a/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
+++ b/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/containers/unord/unord.set/version.pass.cpp b/test/libcxx/containers/unord/unord.set/version.pass.cpp
index d651ebdfc..477867757 100644
--- a/test/libcxx/containers/unord/unord.set/version.pass.cpp
+++ b/test/libcxx/containers/unord/unord.set/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp b/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
index a727b31e4..e78e4ec76 100644
--- a/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
+++ b/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp b/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
index 57d16c272..94ad45b48 100644
--- a/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
+++ b/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/debug/containers/db_string.pass.cpp b/test/libcxx/debug/containers/db_string.pass.cpp
index f6434d5c7..e3b2b290d 100644
--- a/test/libcxx/debug/containers/db_string.pass.cpp
+++ b/test/libcxx/debug/containers/db_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp b/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
index d6a31e366..069c4ae21 100644
--- a/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
+++ b/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/debug/debug_abort.pass.cpp b/test/libcxx/debug/debug_abort.pass.cpp
index 9a1b4753f..a9dae6eea 100644
--- a/test/libcxx/debug/debug_abort.pass.cpp
+++ b/test/libcxx/debug/debug_abort.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/debug/debug_throw.pass.cpp b/test/libcxx/debug/debug_throw.pass.cpp
index d1c88400b..c17546ebd 100644
--- a/test/libcxx/debug/debug_throw.pass.cpp
+++ b/test/libcxx/debug/debug_throw.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/debug/debug_throw_register.pass.cpp b/test/libcxx/debug/debug_throw_register.pass.cpp
index 0d2586bf3..6d345f0ba 100644
--- a/test/libcxx/debug/debug_throw_register.pass.cpp
+++ b/test/libcxx/debug/debug_throw_register.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
index 41ddb179f..3b387b3ab 100644
--- a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
+++ b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
index 3ad9ae8d6..be0ce6617 100644
--- a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
+++ b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp b/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
index 725a7ab13..4009a5ce2 100644
--- a/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
index 7abe8e0a0..4f035e014 100644
--- a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp b/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
index d4d8b5faf..5b036ab41 100644
--- a/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp b/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
index bd4d3501d..63f63ef59 100644
--- a/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.c.headers/math_h.sh.cpp b/test/libcxx/depr/depr.c.headers/math_h.sh.cpp
index 8048865c3..8e0fad78d 100644
--- a/test/libcxx/depr/depr.c.headers/math_h.sh.cpp
+++ b/test/libcxx/depr/depr.c.headers/math_h.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
index 931e3a32f..7252ab00a 100644
--- a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp b/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
index 88c1e21d6..489fc874e 100644
--- a/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
+++ b/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
index beb560800..5ea562628 100644
--- a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
+++ b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/depr.str.strstreams/version.pass.cpp b/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
index f27665f15..9d6b9762e 100644
--- a/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
+++ b/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp b/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
index 9f8a9c088..bd1ee604c 100644
--- a/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
+++ b/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp b/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
index 55e23b9ed..4d49440fc 100644
--- a/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
+++ b/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp b/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
index c4915dd10..43836f4fb 100644
--- a/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
+++ b/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp b/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
index 7a84b92ca..e4d85e1f2 100644
--- a/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
+++ b/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp b/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
index 2a2917625..6a8549128 100644
--- a/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
+++ b/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp b/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
index f123a0525..374ed6fed 100644
--- a/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
+++ b/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/enable_nodiscard.fail.cpp b/test/libcxx/diagnostics/enable_nodiscard.fail.cpp
index e1ef17672..d756c3f9e 100644
--- a/test/libcxx/diagnostics/enable_nodiscard.fail.cpp
+++ b/test/libcxx/diagnostics/enable_nodiscard.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp b/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
index 2c7d899ff..a7a81f53f 100644
--- a/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
+++ b/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp b/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
index c7d080d84..65b3bbeab 100644
--- a/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
+++ b/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp b/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
index 7cd2be8ef..c47c75e8c 100644
--- a/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
+++ b/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/nodiscard.pass.cpp b/test/libcxx/diagnostics/nodiscard.pass.cpp
index de920d459..628ff57ee 100644
--- a/test/libcxx/diagnostics/nodiscard.pass.cpp
+++ b/test/libcxx/diagnostics/nodiscard.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp b/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
index 47e560feb..250f858be 100644
--- a/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
+++ b/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp b/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
index 4db818172..527487faa 100644
--- a/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
+++ b/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp b/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
index d1e0a8af5..6fc95bbeb 100644
--- a/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
+++ b/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp b/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
index 9a09a43ba..bd888e5f9 100644
--- a/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
+++ b/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/std.exceptions/version.pass.cpp b/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
index d9ab009a4..860c18795 100644
--- a/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
+++ b/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/diagnostics/syserr/version.pass.cpp b/test/libcxx/diagnostics/syserr/version.pass.cpp
index 3851150fd..6f2dde8ef 100644
--- a/test/libcxx/diagnostics/syserr/version.pass.cpp
+++ b/test/libcxx/diagnostics/syserr/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/double_include.sh.cpp b/test/libcxx/double_include.sh.cpp
index 5a0f2ba72..249b90947 100644
--- a/test/libcxx/double_include.sh.cpp
+++ b/test/libcxx/double_include.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp b/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
index accdd699c..ecbf562f8 100644
--- a/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
+++ b/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/algorithms/version.pass.cpp b/test/libcxx/experimental/algorithms/version.pass.cpp
index 6d9d0c6b2..d0107209f 100644
--- a/test/libcxx/experimental/algorithms/version.pass.cpp
+++ b/test/libcxx/experimental/algorithms/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp b/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
index 074a9c58c..5d72e5e93 100644
--- a/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp b/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
index c4fb9593a..7d52c955d 100644
--- a/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
+++ b/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/filesystem/version.pass.cpp b/test/libcxx/experimental/filesystem/version.pass.cpp
index d5f36a6b3..09994b6b3 100644
--- a/test/libcxx/experimental/filesystem/version.pass.cpp
+++ b/test/libcxx/experimental/filesystem/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp b/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
index 56f47c8fa..5dfdbe840 100644
--- a/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
+++ b/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp b/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
index 229ce10dd..a80e3013b 100644
--- a/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
+++ b/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
index b2150fcd2..b92771b4b 100644
--- a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
index 020133fc4..ed583e4e0 100644
--- a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp b/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
index ffcedf0bf..cb4076107 100644
--- a/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
index 04b361dfe..78586781c 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
index 11fc21b3b..35faa8389 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
index 9a72979e0..e29220621 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
index 24a1bf304..f0caac427 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
index ff81bc09b..0af172b61 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
index 6b02f46b4..ca5a9faff 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
index b4b7fdf10..99faace64 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
index ab9cc189b..ad49a7338 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
index 37533c7fd..619bdb446 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
index 103d32bec..eb831d6d7 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp b/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
index 341a88c0b..a3c0ba1ea 100644
--- a/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp b/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
index 9b92d02bc..c6b4011ce 100644
--- a/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
index d05575e88..a19049c33 100644
--- a/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp b/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
index 32fd0527d..656010155 100644
--- a/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp b/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
index 37ac584a7..7295852d3 100644
--- a/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
+++ b/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp b/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
index 64f737420..10a2ebc12 100644
--- a/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/strings/string.view/version.pass.cpp b/test/libcxx/experimental/strings/string.view/version.pass.cpp
index 417982e36..c697d67b1 100644
--- a/test/libcxx/experimental/strings/string.view/version.pass.cpp
+++ b/test/libcxx/experimental/strings/string.view/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
index 0bcda7056..69a67ffaf 100644
--- a/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/any/version.pass.cpp b/test/libcxx/experimental/utilities/any/version.pass.cpp
index bc37d8b4d..ed8d6f7e8 100644
--- a/test/libcxx/experimental/utilities/any/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/any/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/meta/version.pass.cpp b/test/libcxx/experimental/utilities/meta/version.pass.cpp
index 593fb52a4..9dd3ca83a 100644
--- a/test/libcxx/experimental/utilities/meta/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/meta/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
index 1711d2f03..8b23ac69a 100644
--- a/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/optional/version.pass.cpp b/test/libcxx/experimental/utilities/optional/version.pass.cpp
index ef011bbe4..ead45ebf5 100644
--- a/test/libcxx/experimental/utilities/optional/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/optional/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
index d9a01337a..682872fce 100644
--- a/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/ratio/version.pass.cpp b/test/libcxx/experimental/utilities/ratio/version.pass.cpp
index 8ebb347a4..990b91c71 100644
--- a/test/libcxx/experimental/utilities/ratio/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/ratio/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
index 9f3d679fc..fc2dc3ad7 100644
--- a/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/time/version.pass.cpp b/test/libcxx/experimental/utilities/time/version.pass.cpp
index 5544a3f0e..f14728679 100644
--- a/test/libcxx/experimental/utilities/time/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/time/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
index 520e9fbb4..0bc33eca7 100644
--- a/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/tuple/version.pass.cpp b/test/libcxx/experimental/utilities/tuple/version.pass.cpp
index c7c9e5728..8e4bae634 100644
--- a/test/libcxx/experimental/utilities/tuple/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/tuple/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/experimental/utilities/utility/version.pass.cpp b/test/libcxx/experimental/utilities/utility/version.pass.cpp
index 437712454..024c56160 100644
--- a/test/libcxx/experimental/utilities/utility/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/utility/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/extensions/hash/specializations.fail.cpp b/test/libcxx/extensions/hash/specializations.fail.cpp
index 8eeffb580..19a726bdc 100644
--- a/test/libcxx/extensions/hash/specializations.fail.cpp
+++ b/test/libcxx/extensions/hash/specializations.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/extensions/hash/specializations.pass.cpp b/test/libcxx/extensions/hash/specializations.pass.cpp
index a222b1eb5..a3f969ba1 100644
--- a/test/libcxx/extensions/hash/specializations.pass.cpp
+++ b/test/libcxx/extensions/hash/specializations.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/extensions/hash_map/const_iterator.fail.cpp b/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
index e4c536e8f..b6389db49 100644
--- a/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
+++ b/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/extensions/nothing_to_do.pass.cpp b/test/libcxx/extensions/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/libcxx/extensions/nothing_to_do.pass.cpp
+++ b/test/libcxx/extensions/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/nth_element.cpp b/test/libcxx/fuzzing/nth_element.cpp
index ee7f0d824..a7f9e9c22 100644
--- a/test/libcxx/fuzzing/nth_element.cpp
+++ b/test/libcxx/fuzzing/nth_element.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------- nth_element.cpp ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/partial_sort.cpp b/test/libcxx/fuzzing/partial_sort.cpp
index 0c5889dbd..2d4d01a09 100644
--- a/test/libcxx/fuzzing/partial_sort.cpp
+++ b/test/libcxx/fuzzing/partial_sort.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===-------------------------- partial_sort.cpp --------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/partial_sort_copy.cpp b/test/libcxx/fuzzing/partial_sort_copy.cpp
index 368eed11b..2a7ccbef4 100644
--- a/test/libcxx/fuzzing/partial_sort_copy.cpp
+++ b/test/libcxx/fuzzing/partial_sort_copy.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------- partial_sort_copy.cpp ------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/partition.cpp b/test/libcxx/fuzzing/partition.cpp
index 03eed8c92..c03f17f98 100644
--- a/test/libcxx/fuzzing/partition.cpp
+++ b/test/libcxx/fuzzing/partition.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- partition.cpp ----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/partition_copy.cpp b/test/libcxx/fuzzing/partition_copy.cpp
index 68d821f63..f7148bbd0 100644
--- a/test/libcxx/fuzzing/partition_copy.cpp
+++ b/test/libcxx/fuzzing/partition_copy.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ partition_copy.cpp --------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/regex_ECMAScript.cpp b/test/libcxx/fuzzing/regex_ECMAScript.cpp
index 2e5712602..51ca6efa7 100644
--- a/test/libcxx/fuzzing/regex_ECMAScript.cpp
+++ b/test/libcxx/fuzzing/regex_ECMAScript.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------- regex_ECMAScript.cpp ---------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/regex_POSIX.cpp b/test/libcxx/fuzzing/regex_POSIX.cpp
index f0bd28919..3fcd1bcda 100644
--- a/test/libcxx/fuzzing/regex_POSIX.cpp
+++ b/test/libcxx/fuzzing/regex_POSIX.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------- regex_POSIX.cpp ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/regex_awk.cpp b/test/libcxx/fuzzing/regex_awk.cpp
index 2e5712602..51ca6efa7 100644
--- a/test/libcxx/fuzzing/regex_awk.cpp
+++ b/test/libcxx/fuzzing/regex_awk.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------- regex_ECMAScript.cpp ---------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/regex_egrep.cpp b/test/libcxx/fuzzing/regex_egrep.cpp
index 056869f52..e44c9e163 100644
--- a/test/libcxx/fuzzing/regex_egrep.cpp
+++ b/test/libcxx/fuzzing/regex_egrep.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ regex_egrep.cpp -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/regex_extended.cpp b/test/libcxx/fuzzing/regex_extended.cpp
index ac850eb5c..dcb7077eb 100644
--- a/test/libcxx/fuzzing/regex_extended.cpp
+++ b/test/libcxx/fuzzing/regex_extended.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------- regex_extended.cpp ----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/regex_grep.cpp b/test/libcxx/fuzzing/regex_grep.cpp
index 5b1dda293..50ef9b941 100644
--- a/test/libcxx/fuzzing/regex_grep.cpp
+++ b/test/libcxx/fuzzing/regex_grep.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ regex_grep.cpp ------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/sort.cpp b/test/libcxx/fuzzing/sort.cpp
index 4c468948d..924c4cf88 100644
--- a/test/libcxx/fuzzing/sort.cpp
+++ b/test/libcxx/fuzzing/sort.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- sort.cpp ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/stable_partition.cpp b/test/libcxx/fuzzing/stable_partition.cpp
index c21e64890..af11cb362 100644
--- a/test/libcxx/fuzzing/stable_partition.cpp
+++ b/test/libcxx/fuzzing/stable_partition.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------- stable_partition.cpp ---------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/stable_sort.cpp b/test/libcxx/fuzzing/stable_sort.cpp
index 1a7bbb952..c32be2486 100644
--- a/test/libcxx/fuzzing/stable_sort.cpp
+++ b/test/libcxx/fuzzing/stable_sort.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ stable_sort.cpp ----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/unique.cpp b/test/libcxx/fuzzing/unique.cpp
index 4bfa25a2b..57317373f 100644
--- a/test/libcxx/fuzzing/unique.cpp
+++ b/test/libcxx/fuzzing/unique.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===--------------------------- unique.cpp -------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/fuzzing/unique_copy.cpp b/test/libcxx/fuzzing/unique_copy.cpp
index ed6fc7ea5..c513e60bd 100644
--- a/test/libcxx/fuzzing/unique_copy.cpp
+++ b/test/libcxx/fuzzing/unique_copy.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------ unique_copy.cpp -----------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/include_as_c.sh.cpp b/test/libcxx/include_as_c.sh.cpp
index db50d835e..f0dd9bef1 100644
--- a/test/libcxx/include_as_c.sh.cpp
+++ b/test/libcxx/include_as_c.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
index 31a37229b..04625da88 100644
--- a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
index 248ab4d67..02c9f1fb8 100644
--- a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp b/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
index 0d7fc5605..0325a45e3 100644
--- a/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp b/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
index bfd379e43..3104bc9aa 100644
--- a/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp b/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
index 84045cf3c..d7e80827a 100644
--- a/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
index 0f8defcbd..ff93466da 100644
--- a/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // <fstream>
diff --git a/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
index 9808d1c09..70621cf79 100644
--- a/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
index 131b58763..e7b787592 100644
--- a/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
index 84a2bf992..793b0f6b8 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
index 81351b557..effbe1e9b 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
index 6741e75ce..453caa384 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
index 8c2e62308..4a847fab3 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp b/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
index c843b7e98..19dd2ac71 100644
--- a/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
index 44b851416..bc578f1b6 100644
--- a/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp b/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp
index 6372755fc..e24ae996e 100644
--- a/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp
+++ b/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp b/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
index 405f9abc2..0a9fdb54f 100644
--- a/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
+++ b/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp b/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
index 992cdebb5..d32b7303a 100644
--- a/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
+++ b/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp b/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
index ff0cc5935..1cfa173da 100644
--- a/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
+++ b/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp b/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
index 21a1a4992..ac64dc7ab 100644
--- a/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
+++ b/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/filesystems/version.pass.cpp b/test/libcxx/input.output/filesystems/version.pass.cpp
index f680217ef..b94e32cbc 100644
--- a/test/libcxx/input.output/filesystems/version.pass.cpp
+++ b/test/libcxx/input.output/filesystems/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp b/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
index a459ec4fb..5be4344ab 100644
--- a/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp b/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
index b03ef2aaa..65c48c11b 100644
--- a/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp b/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
index fab0dd436..caa020f17 100644
--- a/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp b/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
index 662b6987b..f381fcffd 100644
--- a/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp b/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
index ca4fd3d46..775eec295 100644
--- a/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostream.forward/version.pass.cpp b/test/libcxx/input.output/iostream.forward/version.pass.cpp
index cf91332d5..509d7efdb 100644
--- a/test/libcxx/input.output/iostream.forward/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.forward/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostream.objects/version.pass.cpp b/test/libcxx/input.output/iostream.objects/version.pass.cpp
index 09b3611f6..f05cdfff7 100644
--- a/test/libcxx/input.output/iostream.objects/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.objects/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/iostreams.base/version.pass.cpp b/test/libcxx/input.output/iostreams.base/version.pass.cpp
index f56846d38..8090783e9 100644
--- a/test/libcxx/input.output/iostreams.base/version.pass.cpp
+++ b/test/libcxx/input.output/iostreams.base/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/stream.buffers/version.pass.cpp b/test/libcxx/input.output/stream.buffers/version.pass.cpp
index c4b06be60..08cd62785 100644
--- a/test/libcxx/input.output/stream.buffers/version.pass.cpp
+++ b/test/libcxx/input.output/stream.buffers/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp b/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
index f048cae0c..0eeb740aa 100644
--- a/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/input.output/string.streams/version.pass.cpp b/test/libcxx/input.output/string.streams/version.pass.cpp
index 103897106..6725d8509 100644
--- a/test/libcxx/input.output/string.streams/version.pass.cpp
+++ b/test/libcxx/input.output/string.streams/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/iterators/failed.pass.cpp b/test/libcxx/iterators/failed.pass.cpp
index 2e4717b38..b9bcb0250 100644
--- a/test/libcxx/iterators/failed.pass.cpp
+++ b/test/libcxx/iterators/failed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/iterators/trivial_iterators.pass.cpp b/test/libcxx/iterators/trivial_iterators.pass.cpp
index f30c13163..0a77befed 100644
--- a/test/libcxx/iterators/trivial_iterators.pass.cpp
+++ b/test/libcxx/iterators/trivial_iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/iterators/version.pass.cpp b/test/libcxx/iterators/version.pass.cpp
index dd0978503..9fe0a9e2e 100644
--- a/test/libcxx/iterators/version.pass.cpp
+++ b/test/libcxx/iterators/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/cmp/version.pass.cpp b/test/libcxx/language.support/cmp/version.pass.cpp
index 570a7a6ad..ae3a573d7 100644
--- a/test/libcxx/language.support/cmp/version.pass.cpp
+++ b/test/libcxx/language.support/cmp/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/cstdint/version.pass.cpp b/test/libcxx/language.support/cstdint/version.pass.cpp
index 4c9a43a62..31822ac7a 100644
--- a/test/libcxx/language.support/cstdint/version.pass.cpp
+++ b/test/libcxx/language.support/cstdint/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
index 7e3130cf9..043981970 100644
--- a/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
+++ b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/has_c11_features.pass.cpp b/test/libcxx/language.support/has_c11_features.pass.cpp
index 4edec534e..1bba504cd 100644
--- a/test/libcxx/language.support/has_c11_features.pass.cpp
+++ b/test/libcxx/language.support/has_c11_features.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14
diff --git a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
index f62e82d8e..be2e69e68 100644
--- a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
+++ b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp b/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
index d7b4cca63..65943139f 100644
--- a/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
+++ b/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.dynamic/version.pass.cpp b/test/libcxx/language.support/support.dynamic/version.pass.cpp
index ba1ff518e..a3ca4f617 100644
--- a/test/libcxx/language.support/support.dynamic/version.pass.cpp
+++ b/test/libcxx/language.support/support.dynamic/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.exception/version.pass.cpp b/test/libcxx/language.support/support.exception/version.pass.cpp
index acdedbb31..1161e67d0 100644
--- a/test/libcxx/language.support/support.exception/version.pass.cpp
+++ b/test/libcxx/language.support/support.exception/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.initlist/version.pass.cpp b/test/libcxx/language.support/support.initlist/version.pass.cpp
index f3f08cd1f..9b11ce1c6 100644
--- a/test/libcxx/language.support/support.initlist/version.pass.cpp
+++ b/test/libcxx/language.support/support.initlist/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp b/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
index 19b463199..ee03d9ef0 100644
--- a/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
+++ b/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp b/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
index 3fe07a517..94fd729c4 100644
--- a/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
+++ b/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.limits/limits/version.pass.cpp b/test/libcxx/language.support/support.limits/limits/version.pass.cpp
index 0cb3f6f52..4d9ba3892 100644
--- a/test/libcxx/language.support/support.limits/limits/version.pass.cpp
+++ b/test/libcxx/language.support/support.limits/limits/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.limits/version.pass.cpp b/test/libcxx/language.support/support.limits/version.pass.cpp
index c79a69085..e884d285a 100644
--- a/test/libcxx/language.support/support.limits/version.pass.cpp
+++ b/test/libcxx/language.support/support.limits/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.rtti/version.pass.cpp b/test/libcxx/language.support/support.rtti/version.pass.cpp
index 0a9ece34f..84d74db3d 100644
--- a/test/libcxx/language.support/support.rtti/version.pass.cpp
+++ b/test/libcxx/language.support/support.rtti/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp b/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
index 7e37716d0..261dd3cde 100644
--- a/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp b/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
index be1045f1e..a602675ce 100644
--- a/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
index f3ca9389b..1dde2b656 100644
--- a/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
index 0415227e5..219efa153 100644
--- a/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
index db419524f..431e3d9a9 100644
--- a/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp b/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
index ce0bf2cf1..d38788602 100644
--- a/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/language.support/support.types/version.pass.cpp b/test/libcxx/language.support/support.types/version.pass.cpp
index 2ab7c188d..8c05c6563 100644
--- a/test/libcxx/language.support/support.types/version.pass.cpp
+++ b/test/libcxx/language.support/support.types/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/libcpp_alignof.pass.cpp b/test/libcxx/libcpp_alignof.pass.cpp
index ba0df807e..ab64889b5 100644
--- a/test/libcxx/libcpp_alignof.pass.cpp
+++ b/test/libcxx/libcpp_alignof.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/libcpp_version.pass.cpp b/test/libcxx/libcpp_version.pass.cpp
index b83233837..9d7e6dce1 100644
--- a/test/libcxx/libcpp_version.pass.cpp
+++ b/test/libcxx/libcpp_version.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/localization/c.locales/version.pass.cpp b/test/libcxx/localization/c.locales/version.pass.cpp
index 0fce59e2b..5a4f1064c 100644
--- a/test/libcxx/localization/c.locales/version.pass.cpp
+++ b/test/libcxx/localization/c.locales/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp b/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
index b33aab9a7..6da1aa575 100644
--- a/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
+++ b/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/localization/locale.stdcvt/version.pass.cpp b/test/libcxx/localization/locale.stdcvt/version.pass.cpp
index 388538085..1e346afb6 100644
--- a/test/libcxx/localization/locale.stdcvt/version.pass.cpp
+++ b/test/libcxx/localization/locale.stdcvt/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp b/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
index 18cc0ca97..996f6bdc6 100644
--- a/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
+++ b/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp b/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
index 4a7f77ad5..668cb55c6 100644
--- a/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
+++ b/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp b/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
index 3233624d8..6844a0ad0 100644
--- a/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
+++ b/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/localization/version.pass.cpp b/test/libcxx/localization/version.pass.cpp
index a64534c9f..8b73ba589 100644
--- a/test/libcxx/localization/version.pass.cpp
+++ b/test/libcxx/localization/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/memory/aligned_allocation_macro.pass.cpp b/test/libcxx/memory/aligned_allocation_macro.pass.cpp
index 368076dee..b4aad040c 100644
--- a/test/libcxx/memory/aligned_allocation_macro.pass.cpp
+++ b/test/libcxx/memory/aligned_allocation_macro.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/memory/is_allocator.pass.cpp b/test/libcxx/memory/is_allocator.pass.cpp
index 95f1079d6..d0f3e9c27 100644
--- a/test/libcxx/memory/is_allocator.pass.cpp
+++ b/test/libcxx/memory/is_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/min_max_macros.sh.cpp b/test/libcxx/min_max_macros.sh.cpp
index 7b9202d95..8351e5789 100644
--- a/test/libcxx/min_max_macros.sh.cpp
+++ b/test/libcxx/min_max_macros.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/modules/cinttypes_exports.sh.cpp b/test/libcxx/modules/cinttypes_exports.sh.cpp
index ce39ceea4..6e6c515e1 100644
--- a/test/libcxx/modules/cinttypes_exports.sh.cpp
+++ b/test/libcxx/modules/cinttypes_exports.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/modules/clocale_exports.sh.cpp b/test/libcxx/modules/clocale_exports.sh.cpp
index aacddd2d8..480308c1e 100644
--- a/test/libcxx/modules/clocale_exports.sh.cpp
+++ b/test/libcxx/modules/clocale_exports.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/modules/cstdint_exports.sh.cpp b/test/libcxx/modules/cstdint_exports.sh.cpp
index 3d3cbe338..8ecb15c5c 100644
--- a/test/libcxx/modules/cstdint_exports.sh.cpp
+++ b/test/libcxx/modules/cstdint_exports.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/modules/inttypes_h_exports.sh.cpp b/test/libcxx/modules/inttypes_h_exports.sh.cpp
index 5354c8fef..a51608c67 100644
--- a/test/libcxx/modules/inttypes_h_exports.sh.cpp
+++ b/test/libcxx/modules/inttypes_h_exports.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/modules/stdint_h_exports.sh.cpp b/test/libcxx/modules/stdint_h_exports.sh.cpp
index 78e110138..584a46515 100644
--- a/test/libcxx/modules/stdint_h_exports.sh.cpp
+++ b/test/libcxx/modules/stdint_h_exports.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
index a58c389cd..b15467cfd 100644
--- a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
+++ b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/c.math/ctgmath.pass.cpp b/test/libcxx/numerics/c.math/ctgmath.pass.cpp
index 815502f1c..3b7015795 100644
--- a/test/libcxx/numerics/c.math/ctgmath.pass.cpp
+++ b/test/libcxx/numerics/c.math/ctgmath.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
index 37aaa2acf..6007268b2 100644
--- a/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
+++ b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/c.math/tgmath_h.pass.cpp b/test/libcxx/numerics/c.math/tgmath_h.pass.cpp
index 23143c714..3c2388992 100644
--- a/test/libcxx/numerics/c.math/tgmath_h.pass.cpp
+++ b/test/libcxx/numerics/c.math/tgmath_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/c.math/version_cmath.pass.cpp b/test/libcxx/numerics/c.math/version_cmath.pass.cpp
index 1249a902e..b11a6a2e8 100644
--- a/test/libcxx/numerics/c.math/version_cmath.pass.cpp
+++ b/test/libcxx/numerics/c.math/version_cmath.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/cfenv/version.pass.cpp b/test/libcxx/numerics/cfenv/version.pass.cpp
index 727d5bdf3..8b523916a 100644
--- a/test/libcxx/numerics/cfenv/version.pass.cpp
+++ b/test/libcxx/numerics/cfenv/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/numerics/complex.number/__sqr.pass.cpp b/test/libcxx/numerics/complex.number/__sqr.pass.cpp
index a3cc9dd38..4ef3d773b 100644
--- a/test/libcxx/numerics/complex.number/__sqr.pass.cpp
+++ b/test/libcxx/numerics/complex.number/__sqr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index cc98517b9..4fe737ed9 100644
--- a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/complex.number/version.pass.cpp b/test/libcxx/numerics/complex.number/version.pass.cpp
index 316cfec73..c7dfb72dc 100644
--- a/test/libcxx/numerics/complex.number/version.pass.cpp
+++ b/test/libcxx/numerics/complex.number/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/numarray/version.pass.cpp b/test/libcxx/numerics/numarray/version.pass.cpp
index 85457d432..ffe443d09 100644
--- a/test/libcxx/numerics/numarray/version.pass.cpp
+++ b/test/libcxx/numerics/numarray/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/numeric.ops/version.pass.cpp b/test/libcxx/numerics/numeric.ops/version.pass.cpp
index fb6e0a106..2ae08be3e 100644
--- a/test/libcxx/numerics/numeric.ops/version.pass.cpp
+++ b/test/libcxx/numerics/numeric.ops/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp b/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
index eae6c493e..faddb6592 100644
--- a/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
+++ b/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/not_test.sh.cpp b/test/libcxx/selftest/not_test.sh.cpp
index 5b8348f0e..4e0196752 100644
--- a/test/libcxx/selftest/not_test.sh.cpp
+++ b/test/libcxx/selftest/not_test.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test.arc.fail.mm b/test/libcxx/selftest/test.arc.fail.mm
index a185eab13..712947bca 100644
--- a/test/libcxx/selftest/test.arc.fail.mm
+++ b/test/libcxx/selftest/test.arc.fail.mm
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test.arc.pass.mm b/test/libcxx/selftest/test.arc.pass.mm
index ec272a872..df4e83264 100644
--- a/test/libcxx/selftest/test.arc.pass.mm
+++ b/test/libcxx/selftest/test.arc.pass.mm
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test.fail.cpp b/test/libcxx/selftest/test.fail.cpp
index 2ad608bab..7b091c51d 100644
--- a/test/libcxx/selftest/test.fail.cpp
+++ b/test/libcxx/selftest/test.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test.fail.mm b/test/libcxx/selftest/test.fail.mm
index 764daf007..ea3a05421 100644
--- a/test/libcxx/selftest/test.fail.mm
+++ b/test/libcxx/selftest/test.fail.mm
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test.pass.cpp b/test/libcxx/selftest/test.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/libcxx/selftest/test.pass.cpp
+++ b/test/libcxx/selftest/test.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test.pass.mm b/test/libcxx/selftest/test.pass.mm
index b4289556e..e5e5f5c41 100644
--- a/test/libcxx/selftest/test.pass.mm
+++ b/test/libcxx/selftest/test.pass.mm
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test.sh.cpp b/test/libcxx/selftest/test.sh.cpp
index 14dc2db80..b7e5e9d80 100644
--- a/test/libcxx/selftest/test.sh.cpp
+++ b/test/libcxx/selftest/test.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/selftest/test_macros.pass.cpp b/test/libcxx/selftest/test_macros.pass.cpp
index 8d68c2184..63659e594 100644
--- a/test/libcxx/selftest/test_macros.pass.cpp
+++ b/test/libcxx/selftest/test_macros.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
index 920c0d185..4275bad39 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
index 09a6aa8a6..e397e0c85 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
index 1ff02932b..db11f17a1 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
index 46fa5bf43..736677b5e 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
index 3ccbfad70..6f10d3f7e 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
index e493dfea9..f6f23f111 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
index 918cffe73..0446df020 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
index 8a6c3f0cf..4276dfcdb 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
index fbb26d178..39b1fde16 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
index 7ddd2b00d..fb3771d91 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
index a3fa585e4..ca9fb0512 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/c.strings/version_cctype.pass.cpp b/test/libcxx/strings/c.strings/version_cctype.pass.cpp
index e0919d9d2..9a0b4a6f0 100644
--- a/test/libcxx/strings/c.strings/version_cctype.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cctype.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/c.strings/version_cstring.pass.cpp b/test/libcxx/strings/c.strings/version_cstring.pass.cpp
index 87e705aec..a986f294e 100644
--- a/test/libcxx/strings/c.strings/version_cstring.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cstring.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/c.strings/version_cuchar.pass.cpp b/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
index dcfdcc37a..40fa8ef23 100644
--- a/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/strings/c.strings/version_cwchar.pass.cpp b/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
index 72e9855c5..424c85fc2 100644
--- a/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/c.strings/version_cwctype.pass.cpp b/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
index 461482abe..62320f8f5 100644
--- a/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/strings/iterators.exceptions.pass.cpp b/test/libcxx/strings/iterators.exceptions.pass.cpp
index 7dea53c4c..07787edff 100644
--- a/test/libcxx/strings/iterators.exceptions.pass.cpp
+++ b/test/libcxx/strings/iterators.exceptions.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/strings/iterators.noexcept.pass.cpp b/test/libcxx/strings/iterators.noexcept.pass.cpp
index c9d2bf5c2..01c15e3c9 100644
--- a/test/libcxx/strings/iterators.noexcept.pass.cpp
+++ b/test/libcxx/strings/iterators.noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/strings/version.pass.cpp b/test/libcxx/strings/version.pass.cpp
index 0c79c1af2..e378fce09 100644
--- a/test/libcxx/strings/version.pass.cpp
+++ b/test/libcxx/strings/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp b/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
index 805aee138..6109081d1 100644
--- a/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
+++ b/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp b/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
index 88061bb5f..35fde08bd 100644
--- a/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
+++ b/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/futures/futures.task/types.pass.cpp b/test/libcxx/thread/futures/futures.task/types.pass.cpp
index cb0fb803c..22aae509e 100644
--- a/test/libcxx/thread/futures/futures.task/types.pass.cpp
+++ b/test/libcxx/thread/futures/futures.task/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/futures/version.pass.cpp b/test/libcxx/thread/futures/version.pass.cpp
index 6730a1477..ceb0a5561 100644
--- a/test/libcxx/thread/futures/version.pass.cpp
+++ b/test/libcxx/thread/futures/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
index 7463b78af..811883554 100644
--- a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
+++ b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp b/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
index 62e618186..f9facefff 100644
--- a/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.condition/version.pass.cpp b/test/libcxx/thread/thread.condition/version.pass.cpp
index 12a775e83..b3cfd4a3d 100644
--- a/test/libcxx/thread/thread.condition/version.pass.cpp
+++ b/test/libcxx/thread/thread.condition/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
index 161815500..28137444a 100644
--- a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
index f8f404080..2a0eab4f4 100644
--- a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
index d9ac92c27..37f912bd9 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
index 74a465719..58545f8ce 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
index 3ada120cb..5211c5e63 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp b/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
index cf3e63847..9479566a9 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
index e0681048d..772db283a 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/thread.mutex/version.pass.cpp b/test/libcxx/thread/thread.mutex/version.pass.cpp
index 81b52c792..c996c1c7a 100644
--- a/test/libcxx/thread/thread.mutex/version.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
index c818474ba..fa69bec03 100644
--- a/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
index e801fc46a..9d021fe16 100644
--- a/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
index 3c0571bf9..248284ea5 100644
--- a/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/thread/thread.threads/version.pass.cpp b/test/libcxx/thread/thread.threads/version.pass.cpp
index d16b0eb06..07e6c933f 100644
--- a/test/libcxx/thread/thread.threads/version.pass.cpp
+++ b/test/libcxx/thread/thread.threads/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/type_traits/convert_to_integral.pass.cpp b/test/libcxx/type_traits/convert_to_integral.pass.cpp
index 8cac0c7d8..155f985d1 100644
--- a/test/libcxx/type_traits/convert_to_integral.pass.cpp
+++ b/test/libcxx/type_traits/convert_to_integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
index 8cf47a039..84e80afe4 100644
--- a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
+++ b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/utilities/any/size_and_alignment.pass.cpp b/test/libcxx/utilities/any/size_and_alignment.pass.cpp
index a1bdf1604..99ff53273 100644
--- a/test/libcxx/utilities/any/size_and_alignment.pass.cpp
+++ b/test/libcxx/utilities/any/size_and_alignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/any/small_type.pass.cpp b/test/libcxx/utilities/any/small_type.pass.cpp
index 54de0c3ea..f4cd46fdb 100644
--- a/test/libcxx/utilities/any/small_type.pass.cpp
+++ b/test/libcxx/utilities/any/small_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/any/version.pass.cpp b/test/libcxx/utilities/any/version.pass.cpp
index 5edee710d..75e4544ef 100644
--- a/test/libcxx/utilities/any/version.pass.cpp
+++ b/test/libcxx/utilities/any/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
index 7fb1568c0..b2946ab81 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
index 58bb5fd10..15ab7adb4 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
index 0d14a350c..469452706 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp b/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
index 1d4251354..acc0c778f 100644
--- a/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h b/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
index f2a5b08da..766026913 100644
--- a/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
+++ b/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp b/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
index 579e81fe6..de0b9508a 100644
--- a/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
+++ b/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp b/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
index 528a8f327..27e2763db 100644
--- a/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
+++ b/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp b/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
index 319a78b05..7241bc059 100644
--- a/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
+++ b/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/function.objects/version.pass.cpp b/test/libcxx/utilities/function.objects/version.pass.cpp
index 99d731a74..41bbca6f6 100644
--- a/test/libcxx/utilities/function.objects/version.pass.cpp
+++ b/test/libcxx/utilities/function.objects/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
index 6d49cea8b..d0410c51b 100644
--- a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
+++ b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
index 752edb6da..2ff19d45e 100644
--- a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
+++ b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp b/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
index fce8443eb..e3091aa5a 100644
--- a/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
+++ b/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/utilities/memory/version.pass.cpp b/test/libcxx/utilities/memory/version.pass.cpp
index 790c08a3b..e5359a5d4 100644
--- a/test/libcxx/utilities/memory/version.pass.cpp
+++ b/test/libcxx/utilities/memory/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/meta/is_referenceable.pass.cpp b/test/libcxx/utilities/meta/is_referenceable.pass.cpp
index 42b1f2dc3..376f295d1 100644
--- a/test/libcxx/utilities/meta/is_referenceable.pass.cpp
+++ b/test/libcxx/utilities/meta/is_referenceable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
index 886884234..010f8f48d 100644
--- a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
+++ b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
index e3e083bfb..0be653d7f 100644
--- a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
+++ b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/meta/version.pass.cpp b/test/libcxx/utilities/meta/version.pass.cpp
index 3a1033bbb..831ca6672 100644
--- a/test/libcxx/utilities/meta/version.pass.cpp
+++ b/test/libcxx/utilities/meta/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
index cc04e4e87..47fb9d5ad 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
index 6f421153c..5063d69c3 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 62eb6cd34..50e27e99e 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index f13ca92e2..ff66a1ea9 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp b/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
index cdfb02736..d09af830f 100644
--- a/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/optional/version.pass.cpp b/test/libcxx/utilities/optional/version.pass.cpp
index e7581b543..7dc36057c 100644
--- a/test/libcxx/utilities/optional/version.pass.cpp
+++ b/test/libcxx/utilities/optional/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/ratio/version.pass.cpp b/test/libcxx/utilities/ratio/version.pass.cpp
index 26c455fb0..a38c07515 100644
--- a/test/libcxx/utilities/ratio/version.pass.cpp
+++ b/test/libcxx/utilities/ratio/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/template.bitset/includes.pass.cpp b/test/libcxx/utilities/template.bitset/includes.pass.cpp
index 2e3c2812e..78c39989f 100644
--- a/test/libcxx/utilities/template.bitset/includes.pass.cpp
+++ b/test/libcxx/utilities/template.bitset/includes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/template.bitset/version.pass.cpp b/test/libcxx/utilities/template.bitset/version.pass.cpp
index 5ae984c00..9cb31d5fe 100644
--- a/test/libcxx/utilities/template.bitset/version.pass.cpp
+++ b/test/libcxx/utilities/template.bitset/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
index 3a9749e21..8ea12b712 100644
--- a/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
index cd246c631..3e1986bf4 100644
--- a/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
index a6debcbd9..979c92fbd 100644
--- a/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
index c9e55c8fd..a68a5c33f 100644
--- a/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/time/version.pass.cpp b/test/libcxx/utilities/time/version.pass.cpp
index bfa3f6d67..2e3373711 100644
--- a/test/libcxx/utilities/time/version.pass.cpp
+++ b/test/libcxx/utilities/time/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
index 1e7243b5f..76cb442b2 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
index cc222a70e..d1a371b5d 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
index 4808c51cd..2eb85c666 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
index 99b6eb78f..12d226855 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/tuple/version.pass.cpp b/test/libcxx/utilities/tuple/version.pass.cpp
index 2fdbb5d27..8149eb07e 100644
--- a/test/libcxx/utilities/tuple/version.pass.cpp
+++ b/test/libcxx/utilities/tuple/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/type.index/version.pass.cpp b/test/libcxx/utilities/type.index/version.pass.cpp
index 26f462042..94a1ebf43 100644
--- a/test/libcxx/utilities/type.index/version.pass.cpp
+++ b/test/libcxx/utilities/type.index/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp b/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
index 073cfac07..853082012 100644
--- a/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
+++ b/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp b/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
index 54e22a093..9a6739c27 100644
--- a/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
+++ b/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
index 6a3e613e9..6e65d9b52 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
index 0e0117e4e..17a2b5a41 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
index 6a2401223..923bd0dd6 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
index edb3bbf64..68d294bd6 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
index 2dbf5511d..efd7fcb40 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
index 58ea6ecde..076505b46 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
index 8bfeeea5d..fa5f2b6d5 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
index 81dad3bc2..2c636182f 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
index 5d8d36262..c64b92107 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
index 734623388..39d3365aa 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/utility/version.pass.cpp b/test/libcxx/utilities/utility/version.pass.cpp
index 77d145d94..bd64d6e5a 100644
--- a/test/libcxx/utilities/utility/version.pass.cpp
+++ b/test/libcxx/utilities/utility/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp b/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
index c4522682c..224902828 100644
--- a/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
+++ b/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
index c309aaaae..43cb302f9 100644
--- a/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
+++ b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/libcxx/utilities/variant/version.pass.cpp b/test/libcxx/utilities/variant/version.pass.cpp
index 1db93e0e9..c614ee472 100644
--- a/test/libcxx/utilities/variant/version.pass.cpp
+++ b/test/libcxx/utilities/variant/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/nothing_to_do.pass.cpp b/test/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/nothing_to_do.pass.cpp
+++ b/test/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp b/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
+++ b/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
index d2d567f31..c18550a16 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
index 3a2f0f62c..bed5ff636 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
index 19018151f..3d29d6297 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
index 0e5fa63a3..540211752 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
index 1c08fee40..bc6a2c80e 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
index 1e962990b..a133ba63b 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
index 1b1562866..4830ea501 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
index 7e81610ac..5b6712d44 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
index 0c1cc1544..cab5e5a4e 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
index 9b3df5af4..f9a6e77c8 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
index b68b28de4..460cc5e05 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
index ce74684f3..c3749868b 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
index 9738fef35..fcfcc7c79 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
index 1ea9885c1..e6dd5c041 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
index cf23c7743..7e886576f 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
index 3d37d052c..a9aa64e48 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
index 0a14c6695..bfc71e779 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
index db484238c..aa7c74788 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
index e2abf7cce..6a85b995c 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
index 313b6bac4..6cab25cc7 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
index 512acc392..865eb4887 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
index 70b3316d3..3c7651189 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
index 4ace1494d..ab8d6d886 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
index c13788690..c4ad12fa8 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
index 7a0f3405c..35771b5a0 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
index 56a744b2c..2f9dc692a 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
index 32be4e5bc..a7e38b92b 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
index 3d9a5bb73..3daf1109f 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
index eeff40687..d35927a1a 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
index 6c49605b6..d39da5405 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
index e5aa427b9..4758c4f1e 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
index 515c79761..a588b971c 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
index e0e096a6f..5f71e0940 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
index d68efd994..182b17914 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
index 84f2c8c9f..43cd4ce63 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
index b2b894912..dc8101a25 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
index a929291ad..9fc25adc3 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
index dcb09a181..680633745 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
index 48ddcf921..3c34a9a31 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
index 55bfd36d5..b91c05e76 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
index 2936a4e66..d48bb6a67 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp b/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
index 8de06ec7b..de03da4ba 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
index bf445c54d..a542cb81f 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
index 3840350a0..61f6c2cee 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
index 7c80f718f..ea9f8a4c8 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
index bce1095f2..f2e93719e 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
index ff3b6888a..7f6be6a27 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
index 656c7310f..81d46ce62 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
index c6bb06baf..03de33a6b 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
index afcf27b55..36633ee12 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
index ac3b95fbe..2b3ca1b04 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
index 2212285ae..1df8c1b82 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
index f6f1725d6..cb64ee80a 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
index faff926d3..de7a4181c 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
index 0fe084c01..7b0ae435a 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
index 971a94dce..90e952171 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
index 6c6824faf..b43acc13a 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
index a334c6093..66336b2f9 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
index 52ad7befc..3173276d1 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
index cbf87c6c2..914eccdcd 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
index 356c2fbb8..c77ffb220 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
index d483800c2..a3fedafdc 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
index 528ec5696..50d710e67 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
index d5780c7e7..befa432bf 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
index 21a17116f..e61f7f9f0 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
index 4b5ddb191..74502d631 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
index ed9ba055a..2b21daab0 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp b/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
index 04c4c258b..45c50ed01 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
index b27861022..75d7a64a3 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
index 02aea475c..e8b159832 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
index 960e2c1fa..b7b43a829 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
index b6848ec9e..8f99ed99e 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
index b3ef70eb0..0190e0f21 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
index 43bb4c3cc..6748b5ec4 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
index fa8e934b9..5cbb01abe 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
index 50bcff9c9..4fd10376f 100644
--- a/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
index 7d734144d..96c3b43df 100644
--- a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
index c3d6fd919..ec78c10af 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
index 3f290bb29..b48db5423 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
index 96369eb60..78eb5dd70 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
index edd27b0d7..21b21deca 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
index 082cad5f2..9d2bb6e23 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
index 01183d16c..18fffd41e 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
index 8ba0f7194..1f26f6d15 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
index 33b8ff9ae..74474be43 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
index 38d7a425d..d7f681ede 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
index 1b1987aa9..536a2687a 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
index 003138099..cae2c0d9b 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
index 02839abab..8bad526bb 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
index adec6aec8..096c58ce0 100644
--- a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
index b7fbdbfa2..50050c50a 100644
--- a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
index 3743fa535..ebe730728 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
index 992862a4e..ce26335cb 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
index a42936124..f373f0494 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
index 1506a8cd5..c4fd0746b 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
index f453a234d..773e14c46 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
index 6c185c2a8..8488f7003 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
index 471b08cc6..c6e9e634b 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
index 95c7dee2c..0a7d6ef6a 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
index e003acaa5..560051e31 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
index 6b3c72b1d..0cdab3aa4 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
index 3d0241f80..a34cb31e7 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
index 9dc743802..4a815dc0b 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
index 7cd41eaea..b208096d4 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
index da76d2a36..89a9227bd 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
index d212bf6cf..ba8da8dfa 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
index 7435da166..e5f372367 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
index 6ef4d0646..e7c2ffd5f 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
index a2027d440..8eb059119 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
index acede6ff7..14e7b0c06 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
index ff83d7e55..ba7912ed3 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
index dd62dfd78..477a0b893 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
index ab20b2a04..0b834257a 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp b/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
index a1069dee7..d19304458 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
index b43d88fe0..b331239f1 100644
--- a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
index fa30797bd..5f4639427 100644
--- a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
index fb58c718c..74cd21c5c 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
index 8e87e9a43..fed1a2c51 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
index d2fa2cb98..6f11ebda0 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
index 51b7aa8c1..1c78728a5 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
index ca1b42251..72f80df56 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
index 06192f93b..5d959a0a8 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
index c2c20c295..576b2889a 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
index 2b5a6a9f5..8b2f1c049 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
index 8d18027ee..84b5aa0a9 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
index 6b0cfe168..0511d77f8 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
index ea3812a7f..e869169b3 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
index ba1f61a10..a429e59bb 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
index 46578501d..bc5175438 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
index 3d63e3fb9..8ce76754c 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
index 078060176..7af3f23ff 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
index 3652c089c..f500aeb0c 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
index 228aacac6..5a490977b 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
index b2ed76f51..726772c5b 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
index 76724bc39..cb20c0cba 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
index d0b41cca3..ddea611b1 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
index 0ac2a86af..d3e30b9d0 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
index 05a06a9c3..7e52c5747 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
index fb7976713..e1143f592 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
index 6149a574b..c65f13c07 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
index 87d66c472..e6896bea4 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
index 994d3a8c4..9341d6994 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
index 8306cc3b1..6c5dcabfe 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp b/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp b/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
index aec060c4d..ae4af5c97 100644
--- a/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
+++ b/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp b/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
index 4f3b0e330..91aeff282 100644
--- a/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
+++ b/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
index 22bbbd6af..846d86e7a 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
index 1a212c6f3..104c22b57 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
index ae82df919..009c859ff 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
index 154850697..3a40328be 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/clear.pass.cpp b/test/std/atomics/atomics.flag/clear.pass.cpp
index 255af8f17..cc877a477 100644
--- a/test/std/atomics/atomics.flag/clear.pass.cpp
+++ b/test/std/atomics/atomics.flag/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/copy_assign.fail.cpp b/test/std/atomics/atomics.flag/copy_assign.fail.cpp
index 762e3a895..9fa766cad 100644
--- a/test/std/atomics/atomics.flag/copy_assign.fail.cpp
+++ b/test/std/atomics/atomics.flag/copy_assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.flag/copy_ctor.fail.cpp b/test/std/atomics/atomics.flag/copy_ctor.fail.cpp
index 8d6a86537..f167651c9 100644
--- a/test/std/atomics/atomics.flag/copy_ctor.fail.cpp
+++ b/test/std/atomics/atomics.flag/copy_ctor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp b/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
index c58c75554..128778ab9 100644
--- a/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
+++ b/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.flag/default.pass.cpp b/test/std/atomics/atomics.flag/default.pass.cpp
index b4c2b9c80..515e8108c 100644
--- a/test/std/atomics/atomics.flag/default.pass.cpp
+++ b/test/std/atomics/atomics.flag/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/init.pass.cpp b/test/std/atomics/atomics.flag/init.pass.cpp
index c4a121b09..8ca3bc9cc 100644
--- a/test/std/atomics/atomics.flag/init.pass.cpp
+++ b/test/std/atomics/atomics.flag/init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.flag/test_and_set.pass.cpp b/test/std/atomics/atomics.flag/test_and_set.pass.cpp
index 210ba2050..d567734d1 100644
--- a/test/std/atomics/atomics.flag/test_and_set.pass.cpp
+++ b/test/std/atomics/atomics.flag/test_and_set.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.general/nothing_to_do.pass.cpp b/test/std/atomics/atomics.general/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/atomics/atomics.general/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.general/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.general/replace_failure_order.pass.cpp b/test/std/atomics/atomics.general/replace_failure_order.pass.cpp
index cd0683d68..b246fc016 100644
--- a/test/std/atomics/atomics.general/replace_failure_order.pass.cpp
+++ b/test/std/atomics/atomics.general/replace_failure_order.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
index 43436e65a..5d1f3ba9a 100644
--- a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.lockfree/lockfree.pass.cpp b/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
index 0ace9cfe7..cc448e662 100644
--- a/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.order/kill_dependency.pass.cpp b/test/std/atomics/atomics.order/kill_dependency.pass.cpp
index 0f0bafcbb..144bf5059 100644
--- a/test/std/atomics/atomics.order/kill_dependency.pass.cpp
+++ b/test/std/atomics/atomics.order/kill_dependency.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.order/memory_order.pass.cpp b/test/std/atomics/atomics.order/memory_order.pass.cpp
index e734a4c75..69a46eac3 100644
--- a/test/std/atomics/atomics.order/memory_order.pass.cpp
+++ b/test/std/atomics/atomics.order/memory_order.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp b/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.types.generic/address.pass.cpp b/test/std/atomics/atomics.types.generic/address.pass.cpp
index c31a99c9b..98c8d4f24 100644
--- a/test/std/atomics/atomics.types.generic/address.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/address.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.generic/bool.pass.cpp b/test/std/atomics/atomics.types.generic/bool.pass.cpp
index ba38154ed..33901ce9b 100644
--- a/test/std/atomics/atomics.types.generic/bool.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp b/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
index 714fbdc39..0c76e7b0f 100644
--- a/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.generic/integral.pass.cpp b/test/std/atomics/atomics.types.generic/integral.pass.cpp
index 74b8c60a3..e59bee43c 100644
--- a/test/std/atomics/atomics.types.generic/integral.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp b/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
index e4deae1bf..d63043b84 100644
--- a/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp b/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
index 1309f3f1b..6ea65495c 100644
--- a/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
+++ b/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp b/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
index 622643f21..03c68de86 100644
--- a/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
index e40979f45..8d96adeea 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
index 8ac8fc0c2..b557817d6 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
index da0f5c3de..53f4174ec 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
index b70446bdf..7edfb91cd 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
index 680fe8f82..43e6b804b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
index 0df4033c8..14e8ed1af 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
index e30543bdb..deb68b170 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
index 2dc90c9ac..a75acb341 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
index e101029bd..f80d7a82c 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
index 7180c14d4..77a89dc79 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
index 241026bcf..19c321539 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
index c7e0b1232..af0a7e8ab 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
index e1b126474..8298327a9 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
index 882a1f2c4..b7447ad7a 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
index 9306abfd0..5eaf5039f 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
index c6a80a17e..83ac8dbe5 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
index 2ba561fe2..65676339c 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
index 2cac65a83..bcb729469 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
index 27e398736..e8352cd8e 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
index b6d330cef..9431331d6 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
index 1208b7902..d6cf08605 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
index 3f8245bff..6f91792fb 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
index 627a04b74..c63c5cc1b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
index 9f25807fb..9111d8bd0 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
index f6944c725..563a05337 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/Copyable.h b/test/std/containers/Copyable.h
index 9542c7e85..2362df0e1 100644
--- a/test/std/containers/Copyable.h
+++ b/test/std/containers/Copyable.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/Emplaceable.h b/test/std/containers/Emplaceable.h
index 04b1f8543..e1c4ad724 100644
--- a/test/std/containers/Emplaceable.h
+++ b/test/std/containers/Emplaceable.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/NotConstructible.h b/test/std/containers/NotConstructible.h
index 55e648049..f536823af 100644
--- a/test/std/containers/NotConstructible.h
+++ b/test/std/containers/NotConstructible.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/iterator_types.pass.cpp b/test/std/containers/associative/iterator_types.pass.cpp
index 2026219d8..f18fa2b4f 100644
--- a/test/std/containers/associative/iterator_types.pass.cpp
+++ b/test/std/containers/associative/iterator_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp b/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
index 646c6be7d..ff0be2084 100644
--- a/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
+++ b/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/allocator_mismatch.fail.cpp b/test/std/containers/associative/map/allocator_mismatch.fail.cpp
index f5da14539..08f5ee94f 100644
--- a/test/std/containers/associative/map/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/map/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/compare.pass.cpp b/test/std/containers/associative/map/compare.pass.cpp
index 8c429cbd3..fedc9d2b3 100644
--- a/test/std/containers/associative/map/compare.pass.cpp
+++ b/test/std/containers/associative/map/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/incomplete_type.pass.cpp b/test/std/containers/associative/map/incomplete_type.pass.cpp
index 6acf83129..1bc320e9c 100644
--- a/test/std/containers/associative/map/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/map/incomplete_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/at.pass.cpp b/test/std/containers/associative/map/map.access/at.pass.cpp
index 76eda046c..475dd641c 100644
--- a/test/std/containers/associative/map/map.access/at.pass.cpp
+++ b/test/std/containers/associative/map/map.access/at.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/empty.fail.cpp b/test/std/containers/associative/map/map.access/empty.fail.cpp
index 14ac13c99..0305fdb56 100644
--- a/test/std/containers/associative/map/map.access/empty.fail.cpp
+++ b/test/std/containers/associative/map/map.access/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/empty.pass.cpp b/test/std/containers/associative/map/map.access/empty.pass.cpp
index 17b9cfd4e..1317ee310 100644
--- a/test/std/containers/associative/map/map.access/empty.pass.cpp
+++ b/test/std/containers/associative/map/map.access/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/index_key.pass.cpp b/test/std/containers/associative/map/map.access/index_key.pass.cpp
index 5f3d109d1..1d842205a 100644
--- a/test/std/containers/associative/map/map.access/index_key.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp b/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
index bc91475c2..523d4e6d8 100644
--- a/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/index_tuple.pass.cpp b/test/std/containers/associative/map/map.access/index_tuple.pass.cpp
index 8d27eabdf..5f39bece0 100644
--- a/test/std/containers/associative/map/map.access/index_tuple.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_tuple.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/iterator.pass.cpp b/test/std/containers/associative/map/map.access/iterator.pass.cpp
index 27fe3511c..c1c503733 100644
--- a/test/std/containers/associative/map/map.access/iterator.pass.cpp
+++ b/test/std/containers/associative/map/map.access/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/max_size.pass.cpp b/test/std/containers/associative/map/map.access/max_size.pass.cpp
index 9df3b074e..1bb873f4b 100644
--- a/test/std/containers/associative/map/map.access/max_size.pass.cpp
+++ b/test/std/containers/associative/map/map.access/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.access/size.pass.cpp b/test/std/containers/associative/map/map.access/size.pass.cpp
index b9d56167a..4408dc54e 100644
--- a/test/std/containers/associative/map/map.access/size.pass.cpp
+++ b/test/std/containers/associative/map/map.access/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/alloc.pass.cpp b/test/std/containers/associative/map/map.cons/alloc.pass.cpp
index b1c60e0f5..04000bec9 100644
--- a/test/std/containers/associative/map/map.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
index 354911b76..664d6cf08 100644
--- a/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/compare.pass.cpp b/test/std/containers/associative/map/map.cons/compare.pass.cpp
index 326ce74fc..2fb00ebde 100644
--- a/test/std/containers/associative/map/map.cons/compare.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
index 1325f4782..d4de57163 100644
--- a/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
index a1fde845e..1e75326de 100644
--- a/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/copy.pass.cpp b/test/std/containers/associative/map/map.cons/copy.pass.cpp
index 081c8f7c0..0e7266d59 100644
--- a/test/std/containers/associative/map/map.cons/copy.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
index 8391ebab0..0e01b3674 100644
--- a/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp b/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
index 0a4f70e59..e63cbe951 100644
--- a/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/default.pass.cpp b/test/std/containers/associative/map/map.cons/default.pass.cpp
index 29cd4b4ff..3a2b7fb48 100644
--- a/test/std/containers/associative/map/map.cons/default.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
index e06410dcf..61f87b3c1 100644
--- a/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp b/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
index b4b72725f..fb01aacf6 100644
--- a/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
index 7f563b7cf..fb07754c6 100644
--- a/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
index 0504b1adc..b7f916c11 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
index d9c1fb898..887597768 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
index 70783e625..5288d64f0 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
index 48610f3b3..2a17bffb5 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
index 1389f7144..416725783 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
index 923a2124e..c8861573a 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/move.pass.cpp b/test/std/containers/associative/map/map.cons/move.pass.cpp
index 69f762ac5..f2f8dd8a9 100644
--- a/test/std/containers/associative/map/map.cons/move.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
index 5f7ab8ece..728f14c42 100644
--- a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/move_assign.pass.cpp b/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
index 8c0ef6e9a..be06d49c9 100644
--- a/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
index b45e821ad..42bc980b7 100644
--- a/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
index 84a960974..dd61439ca 100644
--- a/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp b/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
index f8cbc15d1..af7accdff 100644
--- a/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/associative/map/map.modifiers/clear.pass.cpp b/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
index ab4642fa8..895a8115a 100644
--- a/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp b/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
index 3b595fc73..8680ab821 100644
--- a/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp b/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
index 7236276a2..1c649093f 100644
--- a/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
index cd65c4302..57de16478 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
index 144cfac2c..875fab538 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
index c1b31e78d..23fae9a60 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp b/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
index ea7fd8907..95ba2b711 100644
--- a/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp b/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
index 41cd09300..70afd45ff 100644
--- a/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
index d98047d02..9adb3d619 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
index e2ffcba37..50801f721 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
index de8191a6b..124a40c33 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
index 0c7e124e0..f993bc202 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
index edc1a1e2c..6315bc40e 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
index 3edb9c06e..45665a411 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
index cc1704c30..3ad5f46b4 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
index 3c6b3e31a..41d264f3f 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
index 8689dc728..69caa8434 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
index 503d92910..439adfde2 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/merge.pass.cpp b/test/std/containers/associative/map/map.modifiers/merge.pass.cpp
index bb75e1d60..1cef30944 100644
--- a/test/std/containers/associative/map/map.modifiers/merge.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp b/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
index 63704c914..43d5c3cac 100644
--- a/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/map/map.ops/count.pass.cpp b/test/std/containers/associative/map/map.ops/count.pass.cpp
index c35ad3f0a..9ac980670 100644
--- a/test/std/containers/associative/map/map.ops/count.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/count0.pass.cpp b/test/std/containers/associative/map/map.ops/count0.pass.cpp
index 5649c57f2..eeaa41a00 100644
--- a/test/std/containers/associative/map/map.ops/count0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/map/map.ops/count1.fail.cpp b/test/std/containers/associative/map/map.ops/count1.fail.cpp
index 9fa9f87b8..049ee980a 100644
--- a/test/std/containers/associative/map/map.ops/count1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/count2.fail.cpp b/test/std/containers/associative/map/map.ops/count2.fail.cpp
index c6380635a..6b4c07572 100644
--- a/test/std/containers/associative/map/map.ops/count2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/count3.fail.cpp b/test/std/containers/associative/map/map.ops/count3.fail.cpp
index 0fddf61b8..525c57cef 100644
--- a/test/std/containers/associative/map/map.ops/count3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp b/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
index 899757e54..fb33d3b0a 100644
--- a/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
index 28747063a..3c0c16fb5 100644
--- a/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
index 310db6d89..27dac20ae 100644
--- a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
index b8c8607ee..629541c1d 100644
--- a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
index 2fb1b2d2e..db3fe9eea 100644
--- a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
index ad499e1c6..bdd1ae681 100644
--- a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
index cce90c695..4387967eb 100644
--- a/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/find.pass.cpp b/test/std/containers/associative/map/map.ops/find.pass.cpp
index b23d303df..ca01e839c 100644
--- a/test/std/containers/associative/map/map.ops/find.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/find0.pass.cpp b/test/std/containers/associative/map/map.ops/find0.pass.cpp
index a11acb103..a684738df 100644
--- a/test/std/containers/associative/map/map.ops/find0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/find0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/map/map.ops/find1.fail.cpp b/test/std/containers/associative/map/map.ops/find1.fail.cpp
index 6c0f237a2..1cad78a39 100644
--- a/test/std/containers/associative/map/map.ops/find1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/find2.fail.cpp b/test/std/containers/associative/map/map.ops/find2.fail.cpp
index b915b4396..cd8858316 100644
--- a/test/std/containers/associative/map/map.ops/find2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/find3.fail.cpp b/test/std/containers/associative/map/map.ops/find3.fail.cpp
index 9303a7f07..62a4a648f 100644
--- a/test/std/containers/associative/map/map.ops/find3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp b/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
index 9c63dc7ab..3572b08f7 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
index 2936da3cb..50752e8da 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
index beb901cf0..095e1b3b3 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
index 2a2258e8f..455e8fa99 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
index 40dc708ad..8c9ac1d65 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp b/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
index 7276b74b1..58ccd7f43 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
index fa97a7144..723cdc6df 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
index be40cec76..fa4afc987 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
index c03c249b7..5be763366 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
index 584833921..773f114f9 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.special/member_swap.pass.cpp b/test/std/containers/associative/map/map.special/member_swap.pass.cpp
index f0913a77c..4f985bae3 100644
--- a/test/std/containers/associative/map/map.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/map/map.special/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp b/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
index 7e36797d0..aea80f9c3 100644
--- a/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp b/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
index c1aa03384..346057415 100644
--- a/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/map/types.pass.cpp b/test/std/containers/associative/map/types.pass.cpp
index 67cd5acaa..f9f7abc28 100644
--- a/test/std/containers/associative/map/types.pass.cpp
+++ b/test/std/containers/associative/map/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp b/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
index 18823212f..f59df265a 100644
--- a/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/empty.fail.cpp b/test/std/containers/associative/multimap/empty.fail.cpp
index 12ca05ef1..91fc1026f 100644
--- a/test/std/containers/associative/multimap/empty.fail.cpp
+++ b/test/std/containers/associative/multimap/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/empty.pass.cpp b/test/std/containers/associative/multimap/empty.pass.cpp
index f1388d8bf..a83e2265c 100644
--- a/test/std/containers/associative/multimap/empty.pass.cpp
+++ b/test/std/containers/associative/multimap/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/incomplete_type.pass.cpp b/test/std/containers/associative/multimap/incomplete_type.pass.cpp
index 306f3d976..5f83dce46 100644
--- a/test/std/containers/associative/multimap/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/multimap/incomplete_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/iterator.pass.cpp b/test/std/containers/associative/multimap/iterator.pass.cpp
index d79dae9e7..f27bce16d 100644
--- a/test/std/containers/associative/multimap/iterator.pass.cpp
+++ b/test/std/containers/associative/multimap/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/max_size.pass.cpp b/test/std/containers/associative/multimap/max_size.pass.cpp
index c836a1823..106bb667c 100644
--- a/test/std/containers/associative/multimap/max_size.pass.cpp
+++ b/test/std/containers/associative/multimap/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
index 40930f0c9..e8c35d5a8 100644
--- a/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
index ae4ab349d..47e4e71a3 100644
--- a/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
index 02fde1a53..5b83bb0be 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
index fc6cef89f..1f11066f8 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
index ee96ed0a1..19276a0ee 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
index b7f5c66ad..c691a1965 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
index cccebfb54..3c549d6ae 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
index b0bf8cc13..d49290868 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
index af1b22bc9..6c59b603b 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
index 6020334ed..d55adedc9 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
index 08ca8a441..8d960dbe3 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
index 2486e8f24..01cdff8c3 100644
--- a/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
index 54b948c3e..bd26b397c 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
index a78e1889a..a3f29e607 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
index ba6f76e52..572a3cfb0 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
index de6d97dbc..0ea352404 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
index 614b3ed8a..aa114a25a 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
index b0e70c444..7d02c7539 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
index 1dc6404b0..324e0a140 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
index 5882283ab..c01591658 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
index 247425415..c1f8e7e5a 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
index 549c1210b..41ea65853 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
index fdcdffbed..b1c148a9f 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp b/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
index 8e786fdc9..dc448f58d 100644
--- a/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
index 546a406fe..0cb5cb29b 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
index 024cc670e..2780d3a53 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
index d5fde83a7..49ee3069b 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
index 6729da413..62ab3f5fd 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
index 1069542c5..f561d149b 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
index 44a6abef6..f881c77c2 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
index 3e00d2b98..a0992d751 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
index ca69cca6b..687043a4c 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
index 225bf67bb..008770cbf 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
index 53874311c..8c4e51b24 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
index 20e0ba17e..2da3e7d49 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
index 05e1096cb..946193446 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
index 1bf437a93..f7a11f86c 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
index 47e0d371b..0912136f1 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
index 906770514..71122d3a3 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
index 82e7d80c0..edc7d2bd3 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
index 022de873f..041ce97a6 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
index f0e38c255..449d5d92d 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
index 7fb2a90a5..7bdb4d200 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
index db84dcf7b..f725d16f8 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
index 393dd2988..28842553b 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
index 3fda00765..5f06d3226 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
index 94453c8f3..2f3aa4dcb 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
index a1dbf806a..0483276f8 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
index 9e67f97f9..47380d881 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
index 0c093898d..48002b381 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
index 396b49ebc..ea7941c71 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
index 1741ee24c..a6fc925a8 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
index f555a31f9..8b5e77242 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
index 2b199d23c..34326a453 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
index 474b7b6ac..006f98b96 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
index 0cff61131..2516b16e7 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
index acea15604..754df859a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
index 38b77684c..898fdbafb 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
index feb6009ed..68608e8d0 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
index 28ff33254..c94f99d49 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
index 4a882af4e..fd604d14e 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
index aec942fa0..510421a8a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
index 1a856ad84..afcf3285a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
index 4b02c97f8..3c7e27676 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
index 4f4b3884f..5a0d7c3ce 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
index d7618141f..5f257ece9 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
index 613194abb..33775d238 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
index 100a45e5e..c2be3e7eb 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
index b90cd0ac6..5c1d2a77b 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp b/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
index f216f9f76..09740b3f3 100644
--- a/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp b/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
index cef658bab..b776766dd 100644
--- a/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
index 8148ea5b2..7c42ff170 100644
--- a/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/scary.pass.cpp b/test/std/containers/associative/multimap/scary.pass.cpp
index e6dc5aaca..2032bfc96 100644
--- a/test/std/containers/associative/multimap/scary.pass.cpp
+++ b/test/std/containers/associative/multimap/scary.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/size.pass.cpp b/test/std/containers/associative/multimap/size.pass.cpp
index 7ba7ceb2b..b608b99e9 100644
--- a/test/std/containers/associative/multimap/size.pass.cpp
+++ b/test/std/containers/associative/multimap/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multimap/types.pass.cpp b/test/std/containers/associative/multimap/types.pass.cpp
index 999ecbb7c..7c91ab3bd 100644
--- a/test/std/containers/associative/multimap/types.pass.cpp
+++ b/test/std/containers/associative/multimap/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp b/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
index b2b30d6fd..ffa0e9640 100644
--- a/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/clear.pass.cpp b/test/std/containers/associative/multiset/clear.pass.cpp
index 59ee02ece..b5ad9e4f3 100644
--- a/test/std/containers/associative/multiset/clear.pass.cpp
+++ b/test/std/containers/associative/multiset/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/count.pass.cpp b/test/std/containers/associative/multiset/count.pass.cpp
index 863da792a..61d64adb6 100644
--- a/test/std/containers/associative/multiset/count.pass.cpp
+++ b/test/std/containers/associative/multiset/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/count_transparent.pass.cpp b/test/std/containers/associative/multiset/count_transparent.pass.cpp
index 9ef223345..e26744a75 100644
--- a/test/std/containers/associative/multiset/count_transparent.pass.cpp
+++ b/test/std/containers/associative/multiset/count_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/emplace.pass.cpp b/test/std/containers/associative/multiset/emplace.pass.cpp
index 7e2628db0..8e7b6946c 100644
--- a/test/std/containers/associative/multiset/emplace.pass.cpp
+++ b/test/std/containers/associative/multiset/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/emplace_hint.pass.cpp b/test/std/containers/associative/multiset/emplace_hint.pass.cpp
index 2b9b92d0b..d8723d8d9 100644
--- a/test/std/containers/associative/multiset/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/multiset/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/empty.fail.cpp b/test/std/containers/associative/multiset/empty.fail.cpp
index 2169a07e4..29c31a089 100644
--- a/test/std/containers/associative/multiset/empty.fail.cpp
+++ b/test/std/containers/associative/multiset/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/empty.pass.cpp b/test/std/containers/associative/multiset/empty.pass.cpp
index acca4e021..f0591d8e3 100644
--- a/test/std/containers/associative/multiset/empty.pass.cpp
+++ b/test/std/containers/associative/multiset/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/equal_range.pass.cpp b/test/std/containers/associative/multiset/equal_range.pass.cpp
index c9f469ba3..740ecc7f2 100644
--- a/test/std/containers/associative/multiset/equal_range.pass.cpp
+++ b/test/std/containers/associative/multiset/equal_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp b/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
index ffd87acfd..075aab1a3 100644
--- a/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/erase_iter.pass.cpp b/test/std/containers/associative/multiset/erase_iter.pass.cpp
index 8ee45c64c..506a0a7c2 100644
--- a/test/std/containers/associative/multiset/erase_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp b/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
index 70d347790..b1e2d143b 100644
--- a/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/erase_key.pass.cpp b/test/std/containers/associative/multiset/erase_key.pass.cpp
index 7293bcfb2..d2c3d17db 100644
--- a/test/std/containers/associative/multiset/erase_key.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/extract_iterator.pass.cpp b/test/std/containers/associative/multiset/extract_iterator.pass.cpp
index 0f41169e9..f16208190 100644
--- a/test/std/containers/associative/multiset/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/multiset/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/extract_key.pass.cpp b/test/std/containers/associative/multiset/extract_key.pass.cpp
index 9ad018410..7fc0459ca 100644
--- a/test/std/containers/associative/multiset/extract_key.pass.cpp
+++ b/test/std/containers/associative/multiset/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/find.pass.cpp b/test/std/containers/associative/multiset/find.pass.cpp
index e20f4f8ce..44d8d051c 100644
--- a/test/std/containers/associative/multiset/find.pass.cpp
+++ b/test/std/containers/associative/multiset/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/incomplete_type.pass.cpp b/test/std/containers/associative/multiset/incomplete_type.pass.cpp
index aecd77a18..71166b2ec 100644
--- a/test/std/containers/associative/multiset/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/multiset/incomplete_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_cv.pass.cpp b/test/std/containers/associative/multiset/insert_cv.pass.cpp
index fe7564282..21fec2cd9 100644
--- a/test/std/containers/associative/multiset/insert_cv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
index 4bd2c88f8..6b6c22f28 100644
--- a/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp b/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
index 23a65a3cc..29a746696 100644
--- a/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp b/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
index ca08bacad..b0da5f4f2 100644
--- a/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp b/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
index fb664d74e..07b8000d9 100644
--- a/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp b/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
index f39fca5c8..3dea1f8a2 100644
--- a/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_node_type.pass.cpp b/test/std/containers/associative/multiset/insert_node_type.pass.cpp
index ca51ec9f0..b8aad6c8c 100644
--- a/test/std/containers/associative/multiset/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp b/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
index 9d0af0653..3e5b40b96 100644
--- a/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/insert_rv.pass.cpp b/test/std/containers/associative/multiset/insert_rv.pass.cpp
index 68d348793..9d50c617d 100644
--- a/test/std/containers/associative/multiset/insert_rv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/iterator.pass.cpp b/test/std/containers/associative/multiset/iterator.pass.cpp
index ec17689f2..bda2c7faa 100644
--- a/test/std/containers/associative/multiset/iterator.pass.cpp
+++ b/test/std/containers/associative/multiset/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/lower_bound.pass.cpp b/test/std/containers/associative/multiset/lower_bound.pass.cpp
index f5ce8e533..dd9fdf70c 100644
--- a/test/std/containers/associative/multiset/lower_bound.pass.cpp
+++ b/test/std/containers/associative/multiset/lower_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/max_size.pass.cpp b/test/std/containers/associative/multiset/max_size.pass.cpp
index 8c5b15e39..64baa6cb0 100644
--- a/test/std/containers/associative/multiset/max_size.pass.cpp
+++ b/test/std/containers/associative/multiset/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/merge.pass.cpp b/test/std/containers/associative/multiset/merge.pass.cpp
index 8ab992889..9d566484c 100644
--- a/test/std/containers/associative/multiset/merge.pass.cpp
+++ b/test/std/containers/associative/multiset/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
index 0a7572275..4debe7b42 100644
--- a/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
index 915a15fc6..f325fe919 100644
--- a/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
index 26ca80120..b628d50ff 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
index 76c9f8b2a..e06c21719 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
index 4f9a6d61b..09c2ac093 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
index 6349dde1e..a055b15fc 100644
--- a/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
index 04a769e73..4466438ca 100644
--- a/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
index cca636325..0efa8bec6 100644
--- a/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
index b5e063e94..a84bc6d10 100644
--- a/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
index 315600323..747e948ed 100644
--- a/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
index 096696fcd..e26828265 100644
--- a/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
index f3ee002dc..c0a682e91 100644
--- a/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
index 3312ca138..719476c7d 100644
--- a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
index e495fce13..61a1f3ca0 100644
--- a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
index ebe8353ba..a1806ecf9 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
index 8a6cf4541..3a37ac014 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
index 0bbaaf12e..77f6b10c4 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
index 7a43cc1c6..8d43c098e 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
index 29797c3ee..f8e12ddca 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
index e767ff1a4..263e48b46 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
index 18d64bc5f..aa164edf0 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
index eab1787ec..41fd86269 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp b/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
index 3c619bb68..19a0d131f 100644
--- a/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp b/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
index 7036138f8..be1132502 100644
--- a/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp b/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
index faa0818cf..9b6d021f5 100644
--- a/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
index 9693ffb15..367e6e1c9 100644
--- a/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/scary.pass.cpp b/test/std/containers/associative/multiset/scary.pass.cpp
index bc4328b53..329f9f18f 100644
--- a/test/std/containers/associative/multiset/scary.pass.cpp
+++ b/test/std/containers/associative/multiset/scary.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/size.pass.cpp b/test/std/containers/associative/multiset/size.pass.cpp
index d11975b79..ccb3f0f7a 100644
--- a/test/std/containers/associative/multiset/size.pass.cpp
+++ b/test/std/containers/associative/multiset/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/types.pass.cpp b/test/std/containers/associative/multiset/types.pass.cpp
index b37b9b328..3ee2fc570 100644
--- a/test/std/containers/associative/multiset/types.pass.cpp
+++ b/test/std/containers/associative/multiset/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/multiset/upper_bound.pass.cpp b/test/std/containers/associative/multiset/upper_bound.pass.cpp
index 8bd00e2f3..f2796d7b4 100644
--- a/test/std/containers/associative/multiset/upper_bound.pass.cpp
+++ b/test/std/containers/associative/multiset/upper_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/allocator_mismatch.fail.cpp b/test/std/containers/associative/set/allocator_mismatch.fail.cpp
index 6905d9344..ed3601968 100644
--- a/test/std/containers/associative/set/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/set/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/clear.pass.cpp b/test/std/containers/associative/set/clear.pass.cpp
index 1be3ed2b8..3f84ee480 100644
--- a/test/std/containers/associative/set/clear.pass.cpp
+++ b/test/std/containers/associative/set/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/count.pass.cpp b/test/std/containers/associative/set/count.pass.cpp
index 115b4fbc2..e915b1cde 100644
--- a/test/std/containers/associative/set/count.pass.cpp
+++ b/test/std/containers/associative/set/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/count_transparent.pass.cpp b/test/std/containers/associative/set/count_transparent.pass.cpp
index 26908eacd..e8490e6de 100644
--- a/test/std/containers/associative/set/count_transparent.pass.cpp
+++ b/test/std/containers/associative/set/count_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/emplace.pass.cpp b/test/std/containers/associative/set/emplace.pass.cpp
index 5d50a2435..fdabf02a8 100644
--- a/test/std/containers/associative/set/emplace.pass.cpp
+++ b/test/std/containers/associative/set/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/emplace_hint.pass.cpp b/test/std/containers/associative/set/emplace_hint.pass.cpp
index 8962c0cbd..441adaf21 100644
--- a/test/std/containers/associative/set/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/set/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/empty.fail.cpp b/test/std/containers/associative/set/empty.fail.cpp
index 0eea6fb67..7954f6f49 100644
--- a/test/std/containers/associative/set/empty.fail.cpp
+++ b/test/std/containers/associative/set/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/empty.pass.cpp b/test/std/containers/associative/set/empty.pass.cpp
index 1eaa8fc90..50ce5dd3b 100644
--- a/test/std/containers/associative/set/empty.pass.cpp
+++ b/test/std/containers/associative/set/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/equal_range.pass.cpp b/test/std/containers/associative/set/equal_range.pass.cpp
index 53fe895bd..da221aa54 100644
--- a/test/std/containers/associative/set/equal_range.pass.cpp
+++ b/test/std/containers/associative/set/equal_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/equal_range_transparent.pass.cpp b/test/std/containers/associative/set/equal_range_transparent.pass.cpp
index 88030847a..c091aa6b5 100644
--- a/test/std/containers/associative/set/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/set/equal_range_transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/erase_iter.pass.cpp b/test/std/containers/associative/set/erase_iter.pass.cpp
index 85be1f5b9..99650d3d0 100644
--- a/test/std/containers/associative/set/erase_iter.pass.cpp
+++ b/test/std/containers/associative/set/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/erase_iter_iter.pass.cpp b/test/std/containers/associative/set/erase_iter_iter.pass.cpp
index 775e6cea0..b98d83ad8 100644
--- a/test/std/containers/associative/set/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/erase_key.pass.cpp b/test/std/containers/associative/set/erase_key.pass.cpp
index 6fc15d9cc..da3ea5c14 100644
--- a/test/std/containers/associative/set/erase_key.pass.cpp
+++ b/test/std/containers/associative/set/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/extract_iterator.pass.cpp b/test/std/containers/associative/set/extract_iterator.pass.cpp
index ffcf71486..da95331f7 100644
--- a/test/std/containers/associative/set/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/set/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/extract_key.pass.cpp b/test/std/containers/associative/set/extract_key.pass.cpp
index 1fb7ab911..68f24f654 100644
--- a/test/std/containers/associative/set/extract_key.pass.cpp
+++ b/test/std/containers/associative/set/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/find.pass.cpp b/test/std/containers/associative/set/find.pass.cpp
index fa1e54740..50b779afd 100644
--- a/test/std/containers/associative/set/find.pass.cpp
+++ b/test/std/containers/associative/set/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/incomplete_type.pass.cpp b/test/std/containers/associative/set/incomplete_type.pass.cpp
index a20022305..96b2bbf59 100644
--- a/test/std/containers/associative/set/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/set/incomplete_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
index b14340b1d..8c60e699a 100644
--- a/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_cv.pass.cpp b/test/std/containers/associative/set/insert_cv.pass.cpp
index 17d3c2623..d29a796ba 100644
--- a/test/std/containers/associative/set/insert_cv.pass.cpp
+++ b/test/std/containers/associative/set/insert_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_initializer_list.pass.cpp b/test/std/containers/associative/set/insert_initializer_list.pass.cpp
index 3114d48ab..46fdecd4f 100644
--- a/test/std/containers/associative/set/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/insert_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_iter_cv.pass.cpp b/test/std/containers/associative/set/insert_iter_cv.pass.cpp
index 12d6402a8..ab8834e6a 100644
--- a/test/std/containers/associative/set/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_iter_iter.pass.cpp b/test/std/containers/associative/set/insert_iter_iter.pass.cpp
index 46edd0db0..bf55e31a8 100644
--- a/test/std/containers/associative/set/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_iter_rv.pass.cpp b/test/std/containers/associative/set/insert_iter_rv.pass.cpp
index 9579988c0..dfe3b52da 100644
--- a/test/std/containers/associative/set/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_node_type.pass.cpp b/test/std/containers/associative/set/insert_node_type.pass.cpp
index 4186f20e7..51826f4fd 100644
--- a/test/std/containers/associative/set/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/set/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_node_type_hint.pass.cpp b/test/std/containers/associative/set/insert_node_type_hint.pass.cpp
index 761ceef6a..2595a3ca2 100644
--- a/test/std/containers/associative/set/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/set/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/insert_rv.pass.cpp b/test/std/containers/associative/set/insert_rv.pass.cpp
index 25cbfcb88..567243ad5 100644
--- a/test/std/containers/associative/set/insert_rv.pass.cpp
+++ b/test/std/containers/associative/set/insert_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/iterator.pass.cpp b/test/std/containers/associative/set/iterator.pass.cpp
index be0a1578d..5212e3fcf 100644
--- a/test/std/containers/associative/set/iterator.pass.cpp
+++ b/test/std/containers/associative/set/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/lower_bound.pass.cpp b/test/std/containers/associative/set/lower_bound.pass.cpp
index 8dfe537b2..b363524d4 100644
--- a/test/std/containers/associative/set/lower_bound.pass.cpp
+++ b/test/std/containers/associative/set/lower_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/max_size.pass.cpp b/test/std/containers/associative/set/max_size.pass.cpp
index 8be84046e..8c2c5fd28 100644
--- a/test/std/containers/associative/set/max_size.pass.cpp
+++ b/test/std/containers/associative/set/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/merge.pass.cpp b/test/std/containers/associative/set/merge.pass.cpp
index bbae22c77..a8b22ea3d 100644
--- a/test/std/containers/associative/set/merge.pass.cpp
+++ b/test/std/containers/associative/set/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/alloc.pass.cpp b/test/std/containers/associative/set/set.cons/alloc.pass.cpp
index 67433ff88..87bdb7aec 100644
--- a/test/std/containers/associative/set/set.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
index 9906a1c0b..269ae1175 100644
--- a/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/compare.pass.cpp b/test/std/containers/associative/set/set.cons/compare.pass.cpp
index 0dac363ca..4a6978d95 100644
--- a/test/std/containers/associative/set/set.cons/compare.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
index 22b3328d4..8264c3f81 100644
--- a/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
index 94ce9cd55..84c0b4ea0 100644
--- a/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/copy.pass.cpp b/test/std/containers/associative/set/set.cons/copy.pass.cpp
index 7bd6342fc..529d951d2 100644
--- a/test/std/containers/associative/set/set.cons/copy.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
index 1ad03dc14..09e7f84ee 100644
--- a/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp b/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
index 7f0f04476..d89c27813 100644
--- a/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/default.pass.cpp b/test/std/containers/associative/set/set.cons/default.pass.cpp
index 3310c51ed..16137d7cc 100644
--- a/test/std/containers/associative/set/set.cons/default.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
index d32cc3f48..0c25901be 100644
--- a/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
index c91038e39..9ee68bf6d 100644
--- a/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp b/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
index 31521b2f3..a0cba90bd 100644
--- a/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
index ea72b6dc0..a0448cdbc 100644
--- a/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
index f6cb734c3..40990948b 100644
--- a/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
index db765bd9e..913efe0da 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
index 13eccbe2a..6e3625d05 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
index 18bc08390..b75cccc4e 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/move.pass.cpp b/test/std/containers/associative/set/set.cons/move.pass.cpp
index ff87799b9..b2d7b0429 100644
--- a/test/std/containers/associative/set/set.cons/move.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
index 9e1cd816b..769023445 100644
--- a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/move_assign.pass.cpp b/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
index 7862f7bf7..bbd787151 100644
--- a/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
index c07d4e6f9..408227e8d 100644
--- a/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
index 901fdbdb3..6945aa39e 100644
--- a/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp b/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
index a55a38c2d..3eecab797 100644
--- a/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/associative/set/set.special/member_swap.pass.cpp b/test/std/containers/associative/set/set.special/member_swap.pass.cpp
index 486d5f442..02324a36a 100644
--- a/test/std/containers/associative/set/set.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/set/set.special/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp b/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
index 0af481870..2420dabf6 100644
--- a/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp b/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
index 38b0ab815..fc0eba646 100644
--- a/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/size.pass.cpp b/test/std/containers/associative/set/size.pass.cpp
index 853aeca74..93b234725 100644
--- a/test/std/containers/associative/set/size.pass.cpp
+++ b/test/std/containers/associative/set/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/types.pass.cpp b/test/std/containers/associative/set/types.pass.cpp
index f1ce8a7c9..3b8c0983b 100644
--- a/test/std/containers/associative/set/types.pass.cpp
+++ b/test/std/containers/associative/set/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/upper_bound.pass.cpp b/test/std/containers/associative/set/upper_bound.pass.cpp
index bafb4377f..315268a60 100644
--- a/test/std/containers/associative/set/upper_bound.pass.cpp
+++ b/test/std/containers/associative/set/upper_bound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/nothing_to_do.pass.cpp b/test/std/containers/container.adaptors/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.adaptors/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.adaptors/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
index 6210a59c3..293356b38 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
index b1d13fb8b..58d61b70e 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
index dc5cca3c5..39c495565 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
index a27a6e205..460906473 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
index a5a073c07..69ed27c07 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
index df255b4cf..d1ca38e02 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
index 82e44b414..12c642561 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
index 4b20b265f..614992094 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
index f435ac306..a195b10fc 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
index 2c73cbc62..561b5d48d 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
index 719f6d980..cb3b97997 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
index f1129bc1b..1c63f7152 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
index 5125a4336..ae0e7badb 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
index b3cd33549..d1cda2029 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
index 360f66393..c147b5cfd 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
index b44d7d38c..b5dd515da 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
index 450dff37c..f2f78685f 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
index 229ec02fc..445bdb566 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
index f3b052794..a37e372ed 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
index bcbe1276a..f175c7d14 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
index e0547d64a..fa0e92a16 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
index 3cedefef2..a6418a3c7 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
index f14c3ae7c..8c3800ba2 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
index 9c2058d47..ae6eb4b08 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
index be928fc2e..5e5dd9f12 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
index c034f22b7..33b97d533 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
index f0c914a04..60499b853 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
index f41b26f68..b6bcb4a72 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
index 288e858f9..8edbe1ad1 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
index 7f4827267..00bdf0c7e 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
index 0ed579e06..51eef9eda 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
index 397d67fab..995e1742a 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
index eddbb926d..22a8174b3 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
index 1a828adde..2c9a39f66 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
index 845ca7587..f2194ccf8 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
index 832f09058..431a4d0d5 100644
--- a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/priority.queue/types.pass.cpp b/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
index 6bc476a3c..6084e5906 100644
--- a/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
index 404db1240..d2a85a348 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
index 06a53fe38..fc3549d2d 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
index 70eaa18f9..6c7fbbc81 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
index 243585693..cc6cb5cdb 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
index 76428e33f..cac8bf3cd 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
index 6832a5f8b..e9c41a0b6 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
index 998f84979..35c2fa013 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
index f4b692236..0a1d3dd96 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
index 57e22963e..a9def3e33 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
index 1b3f25608..00aba51c3 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp b/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
index 1605b96b1..eecb0343b 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
index 58cb7f535..45a6f2e75 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
index 7518bcc71..a53dd9492 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
index 2a6783287..4c87d15e0 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
index 42e1c458c..93f69059f 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
index a89fbef8b..24e96edc5 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
index e9afa0b8c..5fe6b70c6 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
index 0932b7d99..87c9ad197 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
index e91edc283..115360e07 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
index f2696e903..158aa83a9 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
index 25f6bc76e..a8e8791ac 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp b/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
index ce017d2dd..f53f9a805 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
index deac5fa4d..095512c21 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
index 4fbbb0053..7ce29976b 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
index 253a27817..edcb21ea2 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
index 3da2d122f..587cf26c3 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
index 9d462954c..a9e962f8a 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
index 2e0a19a7f..aafc95635 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
index 1c72408f4..f3ecaa5c4 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
index e07449397..9017d2127 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
index 4bd90a88b..b9e018ca1 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
index 7f1883a16..edc41c1a3 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp b/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
index a2ad32fec..ee36779b5 100644
--- a/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp b/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
index af08cbaca..66ef66c7b 100644
--- a/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp b/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
index a3f7c43b7..fcaec66d7 100644
--- a/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
index 542b49011..81d728a27 100644
--- a/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
index bac8378eb..c0023c401 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
index 237870b2c..ef4d25e05 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
index 33cb4dd52..f7c0a9620 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
index b0da1ef8b..f33f638b8 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
index e75a8a267..2889763ec 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
index 7ae12dd70..7db358b3f 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
index 8673e06ce..2bbf7cc93 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
index 82e459a4b..731b2fe4e 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
index d837e3d65..e5c846df1 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
index 01d467460..9ead91521 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp b/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
index e54b51084..bfddd8b59 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
index bb48f0e5e..ec724b063 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
index 03c709ef6..2e901843e 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
index 0a0111b4d..616f46418 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
index d5822839c..0e97c0ff6 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
index 92aef08ba..e7743ad98 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
index 38769e3fb..0f8bf035d 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
index cbb63462a..16609e983 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
index 6830cb716..605440bc4 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp b/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
index 001a38fe3..afdd996ad 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
index a4f728174..37bf18e2d 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
index 7ec1bf187..756eb01c0 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
index 6d5c90890..19615a031 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
index 9165f6ecc..f8ad69e99 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
index 2d8024729..2e2f945b2 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
index 50a29c48a..10c44c0df 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
index 6bde162e3..f58effe19 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
index 8e43d05fc..348946baa 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
index 1cfa8e4da..f343fa109 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
index 77a798b83..33308c1ad 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp b/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
index 9b041f7f8..a6e60f1e0 100644
--- a/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp b/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
index beb937d4c..5494b3dae 100644
--- a/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp b/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
index 90371146d..f8f0ed919 100644
--- a/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
index 121500553..43195ecc8 100644
--- a/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.node/node_handle.pass.cpp b/test/std/containers/container.node/node_handle.pass.cpp
index 1c815a468..37bb73197 100644
--- a/test/std/containers/container.node/node_handle.pass.cpp
+++ b/test/std/containers/container.node/node_handle.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp b/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
index 81f4ad893..3914affd3 100644
--- a/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
+++ b/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/containers.general/nothing_to_do.pass.cpp b/test/std/containers/containers.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/containers.general/nothing_to_do.pass.cpp
+++ b/test/std/containers/containers.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/map_allocator_requirement_test_templates.h b/test/std/containers/map_allocator_requirement_test_templates.h
index 374970d48..64b4b60ca 100644
--- a/test/std/containers/map_allocator_requirement_test_templates.h
+++ b/test/std/containers/map_allocator_requirement_test_templates.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef MAP_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
diff --git a/test/std/containers/nothing_to_do.pass.cpp b/test/std/containers/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/nothing_to_do.pass.cpp
+++ b/test/std/containers/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.cons/deduct.fail.cpp b/test/std/containers/sequences/array/array.cons/deduct.fail.cpp
index c04c9b607..fb882eea0 100644
--- a/test/std/containers/sequences/array/array.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/array/array.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.cons/deduct.pass.cpp b/test/std/containers/sequences/array/array.cons/deduct.pass.cpp
index bfa0bb791..fead8cacf 100644
--- a/test/std/containers/sequences/array/array.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.cons/default.pass.cpp b/test/std/containers/sequences/array/array.cons/default.pass.cpp
index 9a2a6eaa3..22ed4d832 100644
--- a/test/std/containers/sequences/array/array.cons/default.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp b/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
index 7814085e8..9d82c93b5 100644
--- a/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp b/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
index 64ea75a40..6a9da4e4f 100644
--- a/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.data/data.pass.cpp b/test/std/containers/sequences/array/array.data/data.pass.cpp
index ba2c571eb..36640160e 100644
--- a/test/std/containers/sequences/array/array.data/data.pass.cpp
+++ b/test/std/containers/sequences/array/array.data/data.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.data/data_const.pass.cpp b/test/std/containers/sequences/array/array.data/data_const.pass.cpp
index f46352564..3b035e67c 100644
--- a/test/std/containers/sequences/array/array.data/data_const.pass.cpp
+++ b/test/std/containers/sequences/array/array.data/data_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.fill/fill.fail.cpp b/test/std/containers/sequences/array/array.fill/fill.fail.cpp
index 4cd8e60ac..96641c5cb 100644
--- a/test/std/containers/sequences/array/array.fill/fill.fail.cpp
+++ b/test/std/containers/sequences/array/array.fill/fill.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.fill/fill.pass.cpp b/test/std/containers/sequences/array/array.fill/fill.pass.cpp
index 5bc42ceb8..d4dfe9a71 100644
--- a/test/std/containers/sequences/array/array.fill/fill.pass.cpp
+++ b/test/std/containers/sequences/array/array.fill/fill.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.size/size.pass.cpp b/test/std/containers/sequences/array/array.size/size.pass.cpp
index 2fe535512..038df0160 100644
--- a/test/std/containers/sequences/array/array.size/size.pass.cpp
+++ b/test/std/containers/sequences/array/array.size/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.special/swap.pass.cpp b/test/std/containers/sequences/array/array.special/swap.pass.cpp
index 413f291a2..f4751cc76 100644
--- a/test/std/containers/sequences/array/array.special/swap.pass.cpp
+++ b/test/std/containers/sequences/array/array.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.swap/swap.fail.cpp b/test/std/containers/sequences/array/array.swap/swap.fail.cpp
index 638c5b321..3e5dc815c 100644
--- a/test/std/containers/sequences/array/array.swap/swap.fail.cpp
+++ b/test/std/containers/sequences/array/array.swap/swap.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.swap/swap.pass.cpp b/test/std/containers/sequences/array/array.swap/swap.pass.cpp
index 8d01dbf95..e23daa88e 100644
--- a/test/std/containers/sequences/array/array.swap/swap.pass.cpp
+++ b/test/std/containers/sequences/array/array.swap/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/get.fail.cpp b/test/std/containers/sequences/array/array.tuple/get.fail.cpp
index a7e56fcce..25bf53835 100644
--- a/test/std/containers/sequences/array/array.tuple/get.fail.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/get.pass.cpp b/test/std/containers/sequences/array/array.tuple/get.pass.cpp
index 4f210c4f7..bbc1c071a 100644
--- a/test/std/containers/sequences/array/array.tuple/get.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp b/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
index 04606bf6c..7b964870b 100644
--- a/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp b/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
index a22c91a4d..599e919a3 100644
--- a/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp b/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
index 72ef49b15..77d4633db 100644
--- a/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp b/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
index 2139fc1ad..35cd98647 100644
--- a/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
+++ b/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp b/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
index 91d6b4e5d..6980838ab 100644
--- a/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp b/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
index 1e565d194..e542f34ee 100644
--- a/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp b/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
index 0aa2f50d8..ba3c5405d 100644
--- a/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
+++ b/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/at.pass.cpp b/test/std/containers/sequences/array/at.pass.cpp
index 84a8d6f9d..b8d1d2b80 100644
--- a/test/std/containers/sequences/array/at.pass.cpp
+++ b/test/std/containers/sequences/array/at.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/begin.pass.cpp b/test/std/containers/sequences/array/begin.pass.cpp
index 37c6b5eec..ce023aa38 100644
--- a/test/std/containers/sequences/array/begin.pass.cpp
+++ b/test/std/containers/sequences/array/begin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/compare.fail.cpp b/test/std/containers/sequences/array/compare.fail.cpp
index 2aa7cd896..1710fe788 100644
--- a/test/std/containers/sequences/array/compare.fail.cpp
+++ b/test/std/containers/sequences/array/compare.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/compare.pass.cpp b/test/std/containers/sequences/array/compare.pass.cpp
index 5d2bdc50f..56eabbd00 100644
--- a/test/std/containers/sequences/array/compare.pass.cpp
+++ b/test/std/containers/sequences/array/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/contiguous.pass.cpp b/test/std/containers/sequences/array/contiguous.pass.cpp
index 27933b0c5..ce953794a 100644
--- a/test/std/containers/sequences/array/contiguous.pass.cpp
+++ b/test/std/containers/sequences/array/contiguous.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/empty.fail.cpp b/test/std/containers/sequences/array/empty.fail.cpp
index fe118c5f1..424f71541 100644
--- a/test/std/containers/sequences/array/empty.fail.cpp
+++ b/test/std/containers/sequences/array/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/empty.pass.cpp b/test/std/containers/sequences/array/empty.pass.cpp
index 2c01dfc86..485806947 100644
--- a/test/std/containers/sequences/array/empty.pass.cpp
+++ b/test/std/containers/sequences/array/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/front_back.pass.cpp b/test/std/containers/sequences/array/front_back.pass.cpp
index 443f28ddf..13368683a 100644
--- a/test/std/containers/sequences/array/front_back.pass.cpp
+++ b/test/std/containers/sequences/array/front_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/indexing.pass.cpp b/test/std/containers/sequences/array/indexing.pass.cpp
index 7718b92f9..a33a597fc 100644
--- a/test/std/containers/sequences/array/indexing.pass.cpp
+++ b/test/std/containers/sequences/array/indexing.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/iterators.pass.cpp b/test/std/containers/sequences/array/iterators.pass.cpp
index dd4aab30a..7e4c9b756 100644
--- a/test/std/containers/sequences/array/iterators.pass.cpp
+++ b/test/std/containers/sequences/array/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/max_size.pass.cpp b/test/std/containers/sequences/array/max_size.pass.cpp
index 9a3fed395..1f3ec0472 100644
--- a/test/std/containers/sequences/array/max_size.pass.cpp
+++ b/test/std/containers/sequences/array/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/size_and_alignment.pass.cpp b/test/std/containers/sequences/array/size_and_alignment.pass.cpp
index d73182bd5..c57740bca 100644
--- a/test/std/containers/sequences/array/size_and_alignment.pass.cpp
+++ b/test/std/containers/sequences/array/size_and_alignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/array/types.pass.cpp b/test/std/containers/sequences/array/types.pass.cpp
index 9cf390c4e..e76c06e6d 100644
--- a/test/std/containers/sequences/array/types.pass.cpp
+++ b/test/std/containers/sequences/array/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp b/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
index 9223c1ecd..769aa9ec1 100644
--- a/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
index 6f3458a63..b63784312 100644
--- a/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp b/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
index adfd5f2d8..701e31897 100644
--- a/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
index 629a51cab..7adf6656a 100644
--- a/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
index 2365d4e11..d5b3cc521 100644
--- a/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
index 330fd40b7..6ef329ee6 100644
--- a/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
index 3737e727c..02910d8bf 100644
--- a/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
index 0cf038721..e4f0e2bd0 100644
--- a/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
index 4974fc74d..2b89c0490 100644
--- a/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
index bd7db2651..4dcea9782 100644
--- a/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
index fdb751da6..5441583fa 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
index 940d4e8d6..6b3b3f19a 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
index 08325b730..ba18ab24e 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp b/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
index 184054568..bb5bb1393 100644
--- a/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
index 3a49a8bc0..138e6bdc7 100644
--- a/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp b/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
index 61ab9c842..3180384aa 100644
--- a/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp b/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
index a2ec262f1..b349819cc 100644
--- a/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/default.pass.cpp b/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
index 127b08609..bb84f05f4 100644
--- a/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
index e79e6eca3..fea4799d5 100644
--- a/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
index 288810089..3dcc15045 100644
--- a/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
index dd70cda18..b76d0cca5 100644
--- a/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
index 2619569e1..e412e94e7 100644
--- a/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
index 793f2b12a..6c68cd090 100644
--- a/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
index 9ac342a8f..c6391620b 100644
--- a/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/move.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
index a7264a556..ee628c6aa 100644
--- a/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
index 5a9a77c74..3d7af53c4 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
index 8a65bc2d2..325f24c80 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
index 6ea72246f..3facd3084 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
index baae755bc..b5d3331f4 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp b/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
index 6aac6b20c..22f015950 100644
--- a/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
index 117e94289..140bb9c76 100644
--- a/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/size.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
index de7894234..fe378e58f 100644
--- a/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
index 2c8eee7cb..8926a8793 100644
--- a/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
index 6706411c2..80218de73 100644
--- a/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp b/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
index 9a8c698a5..5af8faef4 100644
--- a/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp b/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
index a090eb694..181c73686 100644
--- a/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
index 943b6e8e1..8cfa82406 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
index 33a0b6df3..78278df32 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
index 13773fb1f..835a47a5e 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
index 4c272be48..7f0298cdf 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
index a7a93571f..3a055df9f 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
index 3ed17ab3f..79cb562c1 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
index a0ccd200b..fd08b6afe 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
index 6556ced1a..c81d9a8bb 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
index 6d33424fe..f14da8a81 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
index f843ff3a5..cb36aa280 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
index 4ce8bbdd5..a9f242706 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
index 779b9464e..ced0e360b 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
index e0c2d0129..2e16c342a 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
index 0f5f8e67a..74c48d326 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
index 2336b81d4..1eee65186 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
index d7fd910cc..e773debde 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
index 3de5586ab..672187380 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
index 198cbcf67..be2d72c53 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
index 4c1e15f7a..4bd62b109 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
index 060d83b5e..aa9366956 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
index ef9839721..7e4f7151c 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
index 0688ed025..a6a5200e9 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
index df3d2d099..3ffde9bf3 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.special/copy.pass.cpp b/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
index 846d87c6b..f6ee7737d 100644
--- a/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp b/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
index e7f37f98d..2e51d13ce 100644
--- a/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.special/move.pass.cpp b/test/std/containers/sequences/deque/deque.special/move.pass.cpp
index 1bdbeaf9d..d26132b3f 100644
--- a/test/std/containers/sequences/deque/deque.special/move.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp b/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
index 8e909c63c..0f3ab067f 100644
--- a/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.special/swap.pass.cpp b/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
index 05bbf878a..56310b80c 100644
--- a/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
index 01a10964b..7820480da 100644
--- a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/iterators.pass.cpp b/test/std/containers/sequences/deque/iterators.pass.cpp
index 5c7ae01e6..9fe9326ec 100644
--- a/test/std/containers/sequences/deque/iterators.pass.cpp
+++ b/test/std/containers/sequences/deque/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/deque/types.pass.cpp b/test/std/containers/sequences/deque/types.pass.cpp
index 53b33d9e6..131040092 100644
--- a/test/std/containers/sequences/deque/types.pass.cpp
+++ b/test/std/containers/sequences/deque/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp b/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
index b53075d03..6973d9aee 100644
--- a/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/empty.fail.cpp b/test/std/containers/sequences/forwardlist/empty.fail.cpp
index 78928b480..effcc2733 100644
--- a/test/std/containers/sequences/forwardlist/empty.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/empty.pass.cpp b/test/std/containers/sequences/forwardlist/empty.pass.cpp
index 1226e68ed..6597c66ea 100644
--- a/test/std/containers/sequences/forwardlist/empty.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
index ae14eda50..26bbdb61e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
index cd4d1ede1..205728658 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
index 531afb26c..b70b4e8a2 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
index 244054477..05a74d50d 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
index 69fb6eb4c..20ed6c51a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
index 61118353d..24feee382 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
index 84f1eb996..42f0a43b9 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
index ccefa2df7..098702b44 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
index 1a1610d37..ec8aadf38 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
index 65ab7abe2..551eebb44 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
index 744bba419..bfcb2b490 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
index ef5b20ee7..9c91a031f 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
index c3969a462..e4599d469 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
index 04c4524cf..27eb1577c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
index 57f09d7ce..992636916 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
index 5ff00e6fe..ab61b04f9 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
index 4d295d662..ce3d0f437 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
index 7575c0e81..ac4bcf4a5 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
index cf9cbffa7..05a318778 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
index 92a9e39fc..428fa04f1 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
index 5f5f5d0ae..9337b9b05 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
index d4fe25918..502ca930e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
index a4c776abc..ddd3cfe73 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
index 5a7137463..fb0ec74d6 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
index 03d1c4530..30fe467fd 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
index 061dd6da0..7514d263e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
index 56ce632e0..eee26298e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
index 86338a275..26b3f8c6f 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
index 0163b8607..53e99b48c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
index 69685d2d3..e3e857540 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
index c6104e733..726051b8e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
index d9daf87fb..25c2c312b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
index 6cdf8d57a..5f7ac62c4 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
index 8d7c4e989..70e7d248f 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
index 34591a1e1..121e0178c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
index df859c69a..419ce6891 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
index bf6a88a65..563be1739 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
index 82dca7394..bfc8c04f1 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
index 90ee0d231..1782bc7fd 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
index a41f8dbbf..8ad42aced 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
index 173ccaa62..2aa254bbf 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
index f4b7e3441..e1927945a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
index 545b0e68a..40b092e76 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
index 4b55a0b1d..15e3bfbc1 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
index bff550a0e..3015abb76 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
index 7fc2b9d76..e768cd0ae 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
index 6337cd779..b79e4fd36 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
index 297e2725a..30f99ab96 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
index a67dd1a4b..c2e32a754 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
index 6b4e323bd..6656f9191 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
index b7607e190..fec75668a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
index 4c41f53fa..45a12e7e8 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
index 2876f65d0..e9fe3cae6 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
index 397f209f7..239e5f129 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
index ab6ae6bd3..d7e127bf4 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
index eec9e4263..6b57b3189 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
index cc86c9625..a192627d8 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
index 006869d6d..c836a8bfe 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
index e79abb6b6..ccb0f9a86 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
index 11228afe8..1d4a9a0f3 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/incomplete.pass.cpp b/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
index df273449e..fd789b8c8 100644
--- a/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/max_size.pass.cpp b/test/std/containers/sequences/forwardlist/max_size.pass.cpp
index dc35ac5f5..6b93a3db6 100644
--- a/test/std/containers/sequences/forwardlist/max_size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/forwardlist/types.pass.cpp b/test/std/containers/sequences/forwardlist/types.pass.cpp
index 5ed7e34b9..ff6c10e46 100644
--- a/test/std/containers/sequences/forwardlist/types.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/allocator_mismatch.fail.cpp b/test/std/containers/sequences/list/allocator_mismatch.fail.cpp
index 3490d106a..002954b44 100644
--- a/test/std/containers/sequences/list/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/list/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/incomplete_type.pass.cpp b/test/std/containers/sequences/list/incomplete_type.pass.cpp
index aff8f0367..04b04d0bc 100644
--- a/test/std/containers/sequences/list/incomplete_type.pass.cpp
+++ b/test/std/containers/sequences/list/incomplete_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/iterators.pass.cpp b/test/std/containers/sequences/list/iterators.pass.cpp
index 8103b2435..89cc3932d 100644
--- a/test/std/containers/sequences/list/iterators.pass.cpp
+++ b/test/std/containers/sequences/list/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.capacity/empty.fail.cpp b/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
index fe0387c83..99325fcb6 100644
--- a/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
+++ b/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.capacity/empty.pass.cpp b/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
index b564990f2..27bd73e88 100644
--- a/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp b/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
index e8a48a2db..e3da37d73 100644
--- a/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
index df934699d..04476900d 100644
--- a/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
index 4609ef986..404bb0c1b 100644
--- a/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.capacity/size.pass.cpp b/test/std/containers/sequences/list/list.capacity/size.pass.cpp
index bddaeb5ac..b28b6572f 100644
--- a/test/std/containers/sequences/list/list.capacity/size.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
index 7c8cee2a5..c4493cac7 100644
--- a/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
index 4704cf40a..80d5ad074 100644
--- a/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
index eec214205..7400ba5ca 100644
--- a/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/copy.pass.cpp b/test/std/containers/sequences/list/list.cons/copy.pass.cpp
index fb583a5dd..68b2e9d16 100644
--- a/test/std/containers/sequences/list/list.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
index a164298f4..b722c40e6 100644
--- a/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/deduct.fail.cpp b/test/std/containers/sequences/list/list.cons/deduct.fail.cpp
index 5708d7373..6d9833b5f 100644
--- a/test/std/containers/sequences/list/list.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/list/list.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/deduct.pass.cpp b/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
index b8021ef98..20c017500 100644
--- a/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/default.pass.cpp b/test/std/containers/sequences/list/list.cons/default.pass.cpp
index ce04eef52..ffbfa0b21 100644
--- a/test/std/containers/sequences/list/list.cons/default.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
index 7f3114d6e..b41f7320d 100644
--- a/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
index a5ff2b0c2..1596a4e44 100644
--- a/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
index b5ec50637..64894dc38 100644
--- a/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
index 8f04e7342..61a277395 100644
--- a/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
index 3388e00df..ec560ef8d 100644
--- a/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
index d2c7fa023..ef6e11b25 100644
--- a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/move.pass.cpp b/test/std/containers/sequences/list/list.cons/move.pass.cpp
index 1049b1b03..9ad55ecdb 100644
--- a/test/std/containers/sequences/list/list.cons/move.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
index 7236f7cc6..80ef7cdde 100644
--- a/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
index 0d3ccfa68..b12e3d9e3 100644
--- a/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
index 878dab66f..1b40bbdff 100644
--- a/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
index b638e219d..b0d6a374e 100644
--- a/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/size_type.pass.cpp b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
index cbe790c0f..f11d617e1 100644
--- a/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
index d590626d5..25b3425ab 100644
--- a/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.erasure/erase.pass.cpp b/test/std/containers/sequences/list/list.erasure/erase.pass.cpp
index a9f65c053..6f0b5fc89 100644
--- a/test/std/containers/sequences/list/list.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/list/list.erasure/erase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp b/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
index 99b1c6530..152f66633 100644
--- a/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
index 1d7cb80eb..ba9e413e5 100644
--- a/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
index e8d469412..5183cd9a7 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
index c63b0d8fb..ca428ec65 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
index a9be19e6f..25d7eb37d 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
index 0924fdb84..824c36806 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
index 06b4f0cc6..8166efbd3 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
index 2d5231e78..5cfde77e2 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
index 18460a657..007026649 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
index 5d579fcd2..eefee9123 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
index 9b9236965..2fc8ab7c4 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
index 87a033be6..614f57d12 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
index c5b0277c6..7247e828d 100644
--- a/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
index bb3ad5469..9a0104d03 100644
--- a/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
index 3b05cd729..dba7c0f68 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
index a644955c8..f2b7664a1 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
index 3d9d00abe..0a4c4014b 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
index ed0ef6620..980b2515e 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
index 14379b669..7b6803961 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
index 6fef6ade9..5f74b1597 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/merge.pass.cpp b/test/std/containers/sequences/list/list.ops/merge.pass.cpp
index af4b02ce3..eb60a4165 100644
--- a/test/std/containers/sequences/list/list.ops/merge.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
index 20ddbef62..d2d048b38 100644
--- a/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/remove.pass.cpp b/test/std/containers/sequences/list/list.ops/remove.pass.cpp
index 425070ce2..db6fd89a8 100644
--- a/test/std/containers/sequences/list/list.ops/remove.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/remove.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
index 1b457823d..29dfafaaa 100644
--- a/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/reverse.pass.cpp b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
index 120caba38..a8e5f50a2 100644
--- a/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/sort.pass.cpp b/test/std/containers/sequences/list/list.ops/sort.pass.cpp
index d51aa92dd..9cc92ef0d 100644
--- a/test/std/containers/sequences/list/list.ops/sort.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/sort.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
index 33f2fab0d..f7dc6b0b3 100644
--- a/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
index 41d861da0..e1d9f4c52 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
index 427624a1c..b87e6b825 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
index b7010636d..e4c5752df 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/unique.pass.cpp b/test/std/containers/sequences/list/list.ops/unique.pass.cpp
index fa85b0eae..e5e459491 100644
--- a/test/std/containers/sequences/list/list.ops/unique.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/unique.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
index de6347d46..a3f149d05 100644
--- a/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.special/swap.pass.cpp b/test/std/containers/sequences/list/list.special/swap.pass.cpp
index 54b262572..de98cfe9f 100644
--- a/test/std/containers/sequences/list/list.special/swap.pass.cpp
+++ b/test/std/containers/sequences/list/list.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
index acb68f3b5..c6e4f61ef 100644
--- a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/list/types.pass.cpp b/test/std/containers/sequences/list/types.pass.cpp
index 8c47606fa..bf872fffd 100644
--- a/test/std/containers/sequences/list/types.pass.cpp
+++ b/test/std/containers/sequences/list/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/nothing_to_do.pass.cpp b/test/std/containers/sequences/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/containers/sequences/nothing_to_do.pass.cpp
+++ b/test/std/containers/sequences/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp b/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
index 54b7e84bb..cffc3bfff 100644
--- a/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
index 60146a88b..36d32c73c 100644
--- a/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/assign_move.pass.cpp b/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
index 13cd65f33..59fb08fbf 100644
--- a/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/capacity.pass.cpp b/test/std/containers/sequences/vector.bool/capacity.pass.cpp
index 3cbb09fe4..14ebc6c1e 100644
--- a/test/std/containers/sequences/vector.bool/capacity.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/capacity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
index 80bfce1ad..e481ece9f 100644
--- a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
index bad80c279..44931a75c 100644
--- a/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
index dd4a5c757..49d2c23e0 100644
--- a/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/construct_size.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
index 1fb86a24a..8300924b6 100644
--- a/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
index c66fd4972..ecde42678 100644
--- a/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
index 2ef501271..c94392465 100644
--- a/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/copy.pass.cpp b/test/std/containers/sequences/vector.bool/copy.pass.cpp
index 7e2efad51..66a15a4c8 100644
--- a/test/std/containers/sequences/vector.bool/copy.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
index 56ffb7d52..9a63e5a55 100644
--- a/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
index e2d94e225..bffeaf64c 100644
--- a/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03
diff --git a/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
index 5f1f5d104..9d7858b4f 100644
--- a/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/emplace.pass.cpp b/test/std/containers/sequences/vector.bool/emplace.pass.cpp
index 8a1ed0334..26b903907 100644
--- a/test/std/containers/sequences/vector.bool/emplace.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp b/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
index c737f05fd..0ad721002 100644
--- a/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/empty.fail.cpp b/test/std/containers/sequences/vector.bool/empty.fail.cpp
index 99c245d0c..0381d7eb2 100644
--- a/test/std/containers/sequences/vector.bool/empty.fail.cpp
+++ b/test/std/containers/sequences/vector.bool/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/empty.pass.cpp b/test/std/containers/sequences/vector.bool/empty.pass.cpp
index 1471c39eb..e3226a128 100644
--- a/test/std/containers/sequences/vector.bool/empty.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp b/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
index f8a8dbd8d..ba8bdf531 100644
--- a/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp b/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
index 04e3dd7c2..b0a65c9ae 100644
--- a/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
index 2b9f0e31c..b57455230 100644
--- a/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/find.pass.cpp b/test/std/containers/sequences/vector.bool/find.pass.cpp
index d5c3f458c..265b519de 100644
--- a/test/std/containers/sequences/vector.bool/find.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
index a850fa2f1..9f9967589 100644
--- a/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
index 9a2df4290..29164b598 100644
--- a/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
index df4cb199b..3760a9611 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
index dc4fe44d5..7180bb8c2 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
index 3ec8952ff..9e13af2ac 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
index 6a4a6d4bc..1c0e8ed03 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/iterators.pass.cpp b/test/std/containers/sequences/vector.bool/iterators.pass.cpp
index 10b96480a..0780d1dd0 100644
--- a/test/std/containers/sequences/vector.bool/iterators.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/move.pass.cpp b/test/std/containers/sequences/vector.bool/move.pass.cpp
index b3663c759..e5752e084 100644
--- a/test/std/containers/sequences/vector.bool/move.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
index b3b6f9649..bcf57b6c2 100644
--- a/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
index 556b6e656..60517e206 100644
--- a/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
index f104eb32e..8326e4c42 100644
--- a/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
index 61874338d..5263fa3bd 100644
--- a/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/push_back.pass.cpp b/test/std/containers/sequences/vector.bool/push_back.pass.cpp
index c482f4945..2e7d82d96 100644
--- a/test/std/containers/sequences/vector.bool/push_back.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/push_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
index 8fe18d4b4..22e109142 100644
--- a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/reserve.pass.cpp b/test/std/containers/sequences/vector.bool/reserve.pass.cpp
index 489ca95ee..b7430453f 100644
--- a/test/std/containers/sequences/vector.bool/reserve.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/reserve.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/resize_size.pass.cpp b/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
index bc51e0bbb..3d926910c 100644
--- a/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
index 919000732..061f8a505 100644
--- a/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp b/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
index 03997cbec..988ce6e03 100644
--- a/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/size.pass.cpp b/test/std/containers/sequences/vector.bool/size.pass.cpp
index 43330c0a5..d8abef989 100644
--- a/test/std/containers/sequences/vector.bool/size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/swap.pass.cpp b/test/std/containers/sequences/vector.bool/swap.pass.cpp
index 60b612ae4..9aa579d4a 100644
--- a/test/std/containers/sequences/vector.bool/swap.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
index 68d04dbb3..dbf0f821f 100644
--- a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/types.pass.cpp b/test/std/containers/sequences/vector.bool/types.pass.cpp
index 4e8edc889..4736f8ac9 100644
--- a/test/std/containers/sequences/vector.bool/types.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp b/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
index 89f5a6645..c0d27e4d2 100644
--- a/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp b/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
index 65fdb63ee..001af6298 100644
--- a/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/contiguous.pass.cpp b/test/std/containers/sequences/vector/contiguous.pass.cpp
index 9dfcf7a63..2ac79be6a 100644
--- a/test/std/containers/sequences/vector/contiguous.pass.cpp
+++ b/test/std/containers/sequences/vector/contiguous.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/iterators.pass.cpp b/test/std/containers/sequences/vector/iterators.pass.cpp
index 33093e151..f8b8ca317 100644
--- a/test/std/containers/sequences/vector/iterators.pass.cpp
+++ b/test/std/containers/sequences/vector/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/types.pass.cpp b/test/std/containers/sequences/vector/types.pass.cpp
index 2080ac09f..101355bee 100644
--- a/test/std/containers/sequences/vector/types.pass.cpp
+++ b/test/std/containers/sequences/vector/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
index a87b84061..58dccba22 100644
--- a/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp b/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
index abfdfbfb9..8085bd484 100644
--- a/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
index d81683133..594b9e4f4 100644
--- a/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
index 3ab5cc6a8..3e18d4a4d 100644
--- a/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
index abaa709d4..48f57c99c 100644
--- a/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
index 273bdad9a..d4b282518 100644
--- a/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
index 0bb909710..35b63756a 100644
--- a/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
index daf9b092f..1b8d2815c 100644
--- a/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
index 71f531c48..8944eca42 100644
--- a/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
index 59529a6df..f66eafe25 100644
--- a/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
index d15d24dd9..2c087fb49 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
index 853f75583..c64c8bf3b 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
index f07495637..888ffb105 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
index c2b6b8378..1a915060c 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
index 8e5d2766c..4f0530722 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
index a71f5b32c..c31b3c2fa 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index 60fe2899a..1623c8296 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
index 15498ba41..6cd319bc8 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
index 7416a6ac9..fe20a7036 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
index dcaaa2cd4..c8cd2f2a3 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
index 4713aa157..c0bba42da 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp b/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
index 887444c81..1542827e3 100644
--- a/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
index bf910df05..d54fc59f5 100644
--- a/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp b/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
index d47980012..0ce0bafbf 100644
--- a/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp b/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
index 175fede78..0ada98c0c 100644
--- a/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp b/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
index 1a4a1898c..e7298ba85 100644
--- a/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
index f8c932a02..24f78b282 100644
--- a/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03
diff --git a/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
index 172086694..e02a7b029 100644
--- a/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
index edbad8c0d..a839e0366 100644
--- a/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
index ac5d0178e..f8ea034f7 100644
--- a/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/move.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
index 330bcda8b..e5d625b5e 100644
--- a/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
index 767a0ce3d..dcea27a0d 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
index 14ca7155b..8eeb19eb4 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
index a1e3a632f..a9a554ad2 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
index 21dd5c384..941f1e012 100644
--- a/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.data/data.pass.cpp b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
index 0fc335f15..cd176c701 100644
--- a/test/std/containers/sequences/vector/vector.data/data.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
index fa8b6a8af..33d973954 100644
--- a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp b/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
index e88252f1d..3a96b55ca 100644
--- a/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp b/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
index 8025a3407..f18c40483 100644
--- a/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
index 5357ba4cb..a1ce8f000 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
index d08f4e3c4..7acc90b5a 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
index f70c9b9ab..6ddc88560 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
index e5e0277fa..45835c338 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
index 785a5be8b..def3b350d 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
index 2fc4981b6..aab348f08 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
index 9072d427c..46b6c010a 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
index b54a96d0b..fadd09e3e 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
index 8794d9245..e2190fd88 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
index b6fc9ac73..ddaa4fb6a 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
index 5010f8949..23f0030ab 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
index c44023827..c0784f703 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
index 3b568b7e0..e9bcf2411 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
index eabe029a3..48152cb81 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
index ac1fffd9d..070cabe5c 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.special/swap.pass.cpp b/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
index 0f42d891a..d107be98f 100644
--- a/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
index 062ee22c3..06d89282f 100644
--- a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/set_allocator_requirement_test_templates.h b/test/std/containers/set_allocator_requirement_test_templates.h
index 517c36d8e..992b32b9b 100644
--- a/test/std/containers/set_allocator_requirement_test_templates.h
+++ b/test/std/containers/set_allocator_requirement_test_templates.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SET_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H
diff --git a/test/std/containers/test_compare.h b/test/std/containers/test_compare.h
index 32d831d40..3ce680d03 100644
--- a/test/std/containers/test_compare.h
+++ b/test/std/containers/test_compare.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/test_hash.h b/test/std/containers/test_hash.h
index 1a70e7cbd..b37b24908 100644
--- a/test/std/containers/test_hash.h
+++ b/test/std/containers/test_hash.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/iterator_difference_type.pass.cpp b/test/std/containers/unord/iterator_difference_type.pass.cpp
index 35bcc2794..fe2a83a01 100644
--- a/test/std/containers/unord/iterator_difference_type.pass.cpp
+++ b/test/std/containers/unord/iterator_difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
index 39fcb11ad..9dc9869ea 100644
--- a/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/bucket.pass.cpp b/test/std/containers/unord/unord.map/bucket.pass.cpp
index 8931fdf64..ae65ac887 100644
--- a/test/std/containers/unord/unord.map/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/bucket_count.pass.cpp b/test/std/containers/unord/unord.map/bucket_count.pass.cpp
index 9ab8bfd19..b2529a831 100644
--- a/test/std/containers/unord/unord.map/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/bucket_size.pass.cpp b/test/std/containers/unord/unord.map/bucket_size.pass.cpp
index af25de4db..2edb6cc20 100644
--- a/test/std/containers/unord/unord.map/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/compare.pass.cpp b/test/std/containers/unord/unord.map/compare.pass.cpp
index 2761bf177..6c5891e1a 100644
--- a/test/std/containers/unord/unord.map/compare.pass.cpp
+++ b/test/std/containers/unord/unord.map/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/count.pass.cpp b/test/std/containers/unord/unord.map/count.pass.cpp
index 68661b56d..bd754843c 100644
--- a/test/std/containers/unord/unord.map/count.pass.cpp
+++ b/test/std/containers/unord/unord.map/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/empty.fail.cpp b/test/std/containers/unord/unord.map/empty.fail.cpp
index 1c67169bb..c4fa89e66 100644
--- a/test/std/containers/unord/unord.map/empty.fail.cpp
+++ b/test/std/containers/unord/unord.map/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/empty.pass.cpp b/test/std/containers/unord/unord.map/empty.pass.cpp
index 4488b20b3..1dcba5cf7 100644
--- a/test/std/containers/unord/unord.map/empty.pass.cpp
+++ b/test/std/containers/unord/unord.map/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/eq.pass.cpp b/test/std/containers/unord/unord.map/eq.pass.cpp
index 5dcea6a73..99bd1fa67 100644
--- a/test/std/containers/unord/unord.map/eq.pass.cpp
+++ b/test/std/containers/unord/unord.map/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/equal_range_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
index 46e04fde2..a3b2b5c8a 100644
--- a/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
index 8d7f34a0b..505d355d7 100644
--- a/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/erase_if.pass.cpp b/test/std/containers/unord/unord.map/erase_if.pass.cpp
index f6a580c21..5238d9ee0 100644
--- a/test/std/containers/unord/unord.map/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.map/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/unord/unord.map/find_const.pass.cpp b/test/std/containers/unord/unord.map/find_const.pass.cpp
index 0f0ea68bd..65c2a1208 100644
--- a/test/std/containers/unord/unord.map/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/find_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/find_non_const.pass.cpp b/test/std/containers/unord/unord.map/find_non_const.pass.cpp
index cbce62dab..e6efa8e06 100644
--- a/test/std/containers/unord/unord.map/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/find_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/incomplete_type.pass.cpp b/test/std/containers/unord/unord.map/incomplete_type.pass.cpp
index 9fc0fd471..f6faaac50 100644
--- a/test/std/containers/unord/unord.map/incomplete_type.pass.cpp
+++ b/test/std/containers/unord/unord.map/incomplete_type.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/iterators.pass.cpp b/test/std/containers/unord/unord.map/iterators.pass.cpp
index f99adb52b..609e7d7c4 100644
--- a/test/std/containers/unord/unord.map/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.map/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/load_factor.pass.cpp b/test/std/containers/unord/unord.map/load_factor.pass.cpp
index 2d6162f28..418cdf7fd 100644
--- a/test/std/containers/unord/unord.map/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.map/load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/local_iterators.pass.cpp b/test/std/containers/unord/unord.map/local_iterators.pass.cpp
index 33a428a4f..f51df4878 100644
--- a/test/std/containers/unord/unord.map/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.map/local_iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
index 08f014da2..d9c03128a 100644
--- a/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/max_load_factor.pass.cpp b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
index d9e1d057a..e57eb71d3 100644
--- a/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/max_size.pass.cpp b/test/std/containers/unord/unord.map/max_size.pass.cpp
index d01b52683..3dc62d0b8 100644
--- a/test/std/containers/unord/unord.map/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/rehash.pass.cpp b/test/std/containers/unord/unord.map/rehash.pass.cpp
index 41015726e..ff7b1b75f 100644
--- a/test/std/containers/unord/unord.map/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.map/rehash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/reserve.pass.cpp b/test/std/containers/unord/unord.map/reserve.pass.cpp
index 1836c2a41..983c87237 100644
--- a/test/std/containers/unord/unord.map/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.map/reserve.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/size.pass.cpp b/test/std/containers/unord/unord.map/size.pass.cpp
index 5bf75648f..22a922d1f 100644
--- a/test/std/containers/unord/unord.map/size.pass.cpp
+++ b/test/std/containers/unord/unord.map/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/swap_member.pass.cpp b/test/std/containers/unord/unord.map/swap_member.pass.cpp
index 86a068cd3..2763940f8 100644
--- a/test/std/containers/unord/unord.map/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.map/swap_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/types.pass.cpp b/test/std/containers/unord/unord.map/types.pass.cpp
index ecdc53c54..1c8c86b5d 100644
--- a/test/std/containers/unord/unord.map/types.pass.cpp
+++ b/test/std/containers/unord/unord.map/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
index 6caa59728..0c1ee685b 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
index c6b92744e..2820e66a8 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
index 6bfb7bc18..8f651b929 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
index af98b923d..ab0df753a 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
index 8f6f16c62..1a3cbc386 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
index 0b1d460ef..c8e1d73d0 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
index cf83074ae..939e30c82 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
index 04d172e4d..fe95ce8f8 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
index 7ef7f47ff..cf00bb116 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
index 0fe98abe7..247e57600 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
index aca2a5aa3..3da628240 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
index 1979dd326..6b00cb7c5 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
index ca48808f4..702b9231e 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
index 02360f8ac..57f6dca54 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
index c6a397656..d8d073a4d 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
index 5acc4c34b..0bce91b3a 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
index 808d8946a..fdcd596e9 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
index 296363166..82e83ba48 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
index 4191102a8..71e913f27 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
index 2eb8c9467..09fefc4ba 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
index 94c4bca9b..002a39a86 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
index 426b5dac1..e9ce1a29f 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
index ea058bdff..5240d2b52 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
index 1fdde2b12..a8f69b235 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
index f95efbe5f..9c8f221f3 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
index 94833c232..50252dd5b 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
index acf6b11fe..d9af5a322 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
index 42a248cc1..2c69847d9 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
index 820a3652e..b47f309f9 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
index 58c397c2b..1e821b8c6 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
index a17c49d59..11db9bff7 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
index f7f3a22d5..4ddb9f986 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
index 400e0283f..feea53ecd 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
index 9212a5e3d..6b0f03d9c 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
index 18c83dd31..2ea264b53 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
index ce7fa835c..a130d65c0 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
index 803ecb5ad..78e70fbba 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
index 60b093553..b923752ef 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
index 05046f5de..fcc499ebf 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
index 81a8d3de1..fd9931ad2 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
index 4b103a0ad..9f64445af 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
index 6ef1e07ad..16cf5367f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
index 1185ddf8f..2c5909345 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
index cdd19eb34..aa2dea3d9 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
index 820b12a9b..5c2c676f2 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
index 4cc13ded2..332eea13f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
index 25aa24888..3272a4383 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
index 00c47182c..f84e98c2b 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
index a191ad703..3b4b7db1d 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
index 5c653ee8f..60c5d359c 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
index 471040a33..4670fbfbe 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
index 477a229d0..20b5fb649 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
index d43486488..5840950d7 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
index ef98453b6..3a9786880 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
index e84301e9e..5c02fc129 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
index b722b4a5b..a70703b5f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
index 8c8551e74..ed0a2a58d 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
index 2d5e1843f..17be66154 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
index adc4d6944..dbdb1b89b 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
index 6ab9c923d..e47e7b660 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
index 9497b1523..2522270fd 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
index 2044f42cf..9966bcd4f 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
index 3c740950d..f1e7a2a96 100644
--- a/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/bucket.pass.cpp b/test/std/containers/unord/unord.multimap/bucket.pass.cpp
index 425c63f9d..7b10eb86b 100644
--- a/test/std/containers/unord/unord.multimap/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp b/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
index 5cb60f6a6..340c1dcc2 100644
--- a/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp b/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
index 30c0e5e3c..b7c7d653f 100644
--- a/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/count.pass.cpp b/test/std/containers/unord/unord.multimap/count.pass.cpp
index c93a2237c..15134dd0f 100644
--- a/test/std/containers/unord/unord.multimap/count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
index 8a23edd17..2cffa13a4 100644
--- a/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
index e5a9ce961..62da82f2d 100644
--- a/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
index 2bd161f75..a609b5dd0 100644
--- a/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
index 78b40e14e..a397cad56 100644
--- a/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/empty.fail.cpp b/test/std/containers/unord/unord.multimap/empty.fail.cpp
index 7e3a6f4b9..93ec56e94 100644
--- a/test/std/containers/unord/unord.multimap/empty.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/empty.pass.cpp b/test/std/containers/unord/unord.multimap/empty.pass.cpp
index 68405f229..58f4e602f 100644
--- a/test/std/containers/unord/unord.multimap/empty.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/eq.pass.cpp b/test/std/containers/unord/unord.multimap/eq.pass.cpp
index f95bea3da..85dfb0092 100644
--- a/test/std/containers/unord/unord.multimap/eq.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
index 65c9f8c12..88686a1fd 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
index 10fafee80..5e833c978 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/erase_if.pass.cpp b/test/std/containers/unord/unord.multimap/erase_if.pass.cpp
index dc613269a..ef44cd81b 100644
--- a/test/std/containers/unord/unord.multimap/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/unord/unord.multimap/find_const.pass.cpp b/test/std/containers/unord/unord.multimap/find_const.pass.cpp
index 70c2b45ef..c48d6ffff 100644
--- a/test/std/containers/unord/unord.multimap/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/find_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp b/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
index 0510d1441..b8975ef09 100644
--- a/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/incomplete.pass.cpp b/test/std/containers/unord/unord.multimap/incomplete.pass.cpp
index 67bff9419..77f03f51f 100644
--- a/test/std/containers/unord/unord.multimap/incomplete.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/incomplete.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/iterators.fail.cpp b/test/std/containers/unord/unord.multimap/iterators.fail.cpp
index 5ecaba4e5..aed2f7138 100644
--- a/test/std/containers/unord/unord.multimap/iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/iterators.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/iterators.pass.cpp b/test/std/containers/unord/unord.multimap/iterators.pass.cpp
index 22aa3a0c0..e669be6f3 100644
--- a/test/std/containers/unord/unord.multimap/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/load_factor.pass.cpp b/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
index ff3bc0105..f1624616e 100644
--- a/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp b/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
index 064e1b1bd..313c9e378 100644
--- a/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
index 2976d2c3c..61815a9c6 100644
--- a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
index 3e9a10ab7..b2442ff87 100644
--- a/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp b/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
index 38c8285f5..a75052ebd 100644
--- a/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/max_size.pass.cpp b/test/std/containers/unord/unord.multimap/max_size.pass.cpp
index 228575c2e..5ed732902 100644
--- a/test/std/containers/unord/unord.multimap/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index e8394d7f7..aa8996a1a 100644
--- a/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/reserve.pass.cpp b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
index 003337774..1771faa60 100644
--- a/test/std/containers/unord/unord.multimap/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/scary.pass.cpp b/test/std/containers/unord/unord.multimap/scary.pass.cpp
index ad32ff713..321c38ceb 100644
--- a/test/std/containers/unord/unord.multimap/scary.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/scary.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/size.pass.cpp b/test/std/containers/unord/unord.multimap/size.pass.cpp
index b12966240..c24d93b5b 100644
--- a/test/std/containers/unord/unord.multimap/size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
index 3f0259794..f57d82109 100644
--- a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/types.pass.cpp b/test/std/containers/unord/unord.multimap/types.pass.cpp
index e14123490..5e7e1451b 100644
--- a/test/std/containers/unord/unord.multimap/types.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
index 19877738a..dadd81765 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
index d5729e350..3b2b0cba7 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
index f06ed700f..cae8605db 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
index 11a1759bb..f91872111 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
index cb0ce522d..7438bf530 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
index 5e314db06..7747aef54 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
index cb221abd4..41b5f537d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
index 8418c885e..3cd4da37e 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
index d924ef15c..4866dde5d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
index 2fbe7a674..f276bf777 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
index f5f42e5d2..f6b8cb23e 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
index b3519fd50..43fb0f971 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
index ef75b6ce0..37bf73b5c 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
index 998125391..9fbc5893f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
index 1ca94641c..398103dee 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
index e8efefbee..2f81c2a01 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
index df69b5287..4bfc4d3b7 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
index 0e004522c..2b711513b 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
index 2d5766946..649dfd94b 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
index 7f3a337bd..c1f6d3143 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
index 7baf11f52..3158236a4 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
index bc16de5a2..731207ef6 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
index 9ecfc5b79..a009d1372 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
index 7c4c53578..b6548bcc5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
index 782105cb0..288ad6dd3 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
index b76fbc0ba..284618117 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
index ae3d4f816..3c8c46bab 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
index 742d4f291..b299639ee 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
index 88cce517c..2507e5e8f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
index 2b3b0e2ab..d9c6a60df 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
index 15c78208a..2db684a52 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
index 68e5267a9..aa38084df 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
index 86950e289..3729b9e5f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
index 092f3dd91..044425256 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
index 83ccf3b73..4986848cd 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
index fffcfa691..035a796e9 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
index be6caba59..8f38b65ef 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
index a6d54084e..7d6a7794a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
index 301cfb440..2502f123d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
index b53b486a5..a098f2a66 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
index 0da6f8a56..7a94e3489 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
index f239af4af..46ca4b40d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
index adb2ddb2b..b3ecc3556 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
index 8cf26fc77..fb27c1434 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
index 30f78936f..855b5ea61 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
index b87b7e372..112af3ca4 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
index 34cb1b293..b21adc888 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
index 94faa8f7f..1485e2a83 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
index ef1577170..a707f77c5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
index 93c0462b3..bbaf6aac0 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
index 99a47cabb..ae36abb92 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
index 483f22050..4d0f37dbb 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
index 0c8ffeb10..58bb72379 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
index b7f61ca5a..0f590972f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
index a332b6fa4..8b0b8a498 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
index 33d8e3c36..6162cb2ff 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
index 644af867d..7b639ef55 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
index 5836cb366..1ff880b4e 100644
--- a/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/bucket.pass.cpp b/test/std/containers/unord/unord.multiset/bucket.pass.cpp
index b0fb9b334..a0837f9fd 100644
--- a/test/std/containers/unord/unord.multiset/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp b/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
index c60a81167..b6f734961 100644
--- a/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp b/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
index 237b89036..78e8c6826 100644
--- a/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/clear.pass.cpp b/test/std/containers/unord/unord.multiset/clear.pass.cpp
index b699d0624..449de3520 100644
--- a/test/std/containers/unord/unord.multiset/clear.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/count.pass.cpp b/test/std/containers/unord/unord.multiset/count.pass.cpp
index 9f61845fa..2eb50539b 100644
--- a/test/std/containers/unord/unord.multiset/count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
index 91f083b24..7f82cf65c 100644
--- a/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
index 3d78ed4c0..305a76f24 100644
--- a/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
index cf8874803..e12e3cefb 100644
--- a/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
index 46e5ba7d5..51ccf32ae 100644
--- a/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/emplace.pass.cpp b/test/std/containers/unord/unord.multiset/emplace.pass.cpp
index 5d925c8d4..efbaa35aa 100644
--- a/test/std/containers/unord/unord.multiset/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp b/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
index d9bab1f49..715b77425 100644
--- a/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/empty.fail.cpp b/test/std/containers/unord/unord.multiset/empty.fail.cpp
index 8e068a4e1..1aeffd599 100644
--- a/test/std/containers/unord/unord.multiset/empty.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/empty.pass.cpp b/test/std/containers/unord/unord.multiset/empty.pass.cpp
index 8c65bc23b..f96e944a3 100644
--- a/test/std/containers/unord/unord.multiset/empty.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/eq.pass.cpp b/test/std/containers/unord/unord.multiset/eq.pass.cpp
index 9c59d0cf5..6681e05ee 100644
--- a/test/std/containers/unord/unord.multiset/eq.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp b/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
index e89410e61..77bfb557b 100644
--- a/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
index a9373cec6..c3da35a48 100644
--- a/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
index 362697b2c..daa39956a 100644
--- a/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_if.pass.cpp b/test/std/containers/unord/unord.multiset/erase_if.pass.cpp
index 7a9d93d43..761b94e1d 100644
--- a/test/std/containers/unord/unord.multiset/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
index baad3858b..742fe2bc2 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
index a21f29ef7..9a6e09d47 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
index 03c9ec5d0..dac9ac6af 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
index 4c6f209f1..f2eb5277e 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
index 5ce378974..a3e2d8cce 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
index 7c362a2a2..41cc1f873 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_key.pass.cpp b/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
index e8ff71d03..1ed8cd704 100644
--- a/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/erase_range.pass.cpp b/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
index 14eb7c477..8c1f8479a 100644
--- a/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp b/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
index 1595c55a4..e0a0f96b9 100644
--- a/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/extract_key.pass.cpp b/test/std/containers/unord/unord.multiset/extract_key.pass.cpp
index ffe46fb30..78d763ff5 100644
--- a/test/std/containers/unord/unord.multiset/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/find_const.pass.cpp b/test/std/containers/unord/unord.multiset/find_const.pass.cpp
index 505266b1f..8d6da1945 100644
--- a/test/std/containers/unord/unord.multiset/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/find_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp b/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
index 32ee79aa7..713f1ebe1 100644
--- a/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/incomplete.pass.cpp b/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
index 1b3c1492c..67fe1a9c0 100644
--- a/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
@@ -2,10 +2,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
index 414e8fa48..90666e0c1 100644
--- a/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
index 4b6e2f769..bc14294c3 100644
--- a/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
index 8ce6a5efb..283368091 100644
--- a/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
index ffe6534b2..39c04a1b6 100644
--- a/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_init.pass.cpp b/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
index 88661b569..60d58c0d2 100644
--- a/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp b/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
index c3d4cd2a0..0a06fe6b9 100644
--- a/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
index 79712d3de..364346805 100644
--- a/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_range.pass.cpp b/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
index 3d36ff9d4..2487a2d4b 100644
--- a/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
index 893949010..056288c78 100644
--- a/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/iterators.fail.cpp b/test/std/containers/unord/unord.multiset/iterators.fail.cpp
index 9f309a234..3cf31d52c 100644
--- a/test/std/containers/unord/unord.multiset/iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/iterators.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/iterators.pass.cpp b/test/std/containers/unord/unord.multiset/iterators.pass.cpp
index d87099cda..b6147e9c6 100644
--- a/test/std/containers/unord/unord.multiset/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/load_factor.pass.cpp b/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
index df2cb7bef..ece450ceb 100644
--- a/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp b/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
index a43e49357..a27353414 100644
--- a/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp b/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
index 8ba9f0f95..b63a94ae1 100644
--- a/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
index 510ba5fe4..c503a3537 100644
--- a/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp b/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
index f7ebaaf65..1a6b1335a 100644
--- a/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/max_size.pass.cpp b/test/std/containers/unord/unord.multiset/max_size.pass.cpp
index e76624e5c..a6a7dae25 100644
--- a/test/std/containers/unord/unord.multiset/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/merge.pass.cpp b/test/std/containers/unord/unord.multiset/merge.pass.cpp
index 7913f9564..1082f4990 100644
--- a/test/std/containers/unord/unord.multiset/merge.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/rehash.pass.cpp b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
index 83fb58d8a..38691f200 100644
--- a/test/std/containers/unord/unord.multiset/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/reserve.pass.cpp b/test/std/containers/unord/unord.multiset/reserve.pass.cpp
index 28187e9ca..079786689 100644
--- a/test/std/containers/unord/unord.multiset/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/reserve.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/scary.pass.cpp b/test/std/containers/unord/unord.multiset/scary.pass.cpp
index aec6950c4..7ef4a513f 100644
--- a/test/std/containers/unord/unord.multiset/scary.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/scary.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/size.pass.cpp b/test/std/containers/unord/unord.multiset/size.pass.cpp
index 2c23202ce..3aae7dd53 100644
--- a/test/std/containers/unord/unord.multiset/size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/swap_member.pass.cpp b/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
index 9ffe3ad48..2937e444e 100644
--- a/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/types.pass.cpp b/test/std/containers/unord/unord.multiset/types.pass.cpp
index ee5c2c38a..8b246778d 100644
--- a/test/std/containers/unord/unord.multiset/types.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
index 867ca93fb..e446fa65e 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
index e1794c0d8..c90a0106a 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
index 5ab0209ce..cf286319d 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
index 17ac618fa..00adca3c4 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
index 1b81905b6..b1e161b42 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
index 3ba35d7a5..e3a57fa55 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
index 2c018e077..aac5fde6a 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
index 4b4487f00..85fc84896 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
index 3b69c1eed..71661d5ea 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
index 1e927b9b3..c65c0f15e 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
index cae8ab973..97b031ab8 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
index d98b9a7d0..7b3d996f7 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
index b83507934..475f2664d 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
index 92edfc35b..de5f6ae17 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
index 877306db6..cffd9d55e 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
index e77be8463..57df30145 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
index 9fbb773a4..670102be4 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
index fb144d9b1..5e822b458 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
index 7336bb5af..702125b66 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
index fcf2a5af3..03f61a504 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
index fd3b76316..5d729ec49 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
index f09f9c860..d423c8864 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
index 167216bf6..84f7d5a13 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
index 8720f59a8..93d92257c 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
index 3373dd0d4..e8e425f2d 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
index c3056d2f9..d115f98fe 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
index c6f12e9ac..2e1c749f2 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
index 10d48b73e..3868b3720 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
index 6b545a1da..eebcc14a6 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
index 5c87a3a20..ab2ac6ee5 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
index 9470b1a6f..3ad54c42f 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
index 4afef42e6..73c3cc66a 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
index ce290ff1c..60826ffd1 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
index b87c9a24d..6286031e5 100644
--- a/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/bucket.pass.cpp b/test/std/containers/unord/unord.set/bucket.pass.cpp
index 3903d96c1..58d77e3d5 100644
--- a/test/std/containers/unord/unord.set/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/bucket_count.pass.cpp b/test/std/containers/unord/unord.set/bucket_count.pass.cpp
index 227d9e123..3dadbd21a 100644
--- a/test/std/containers/unord/unord.set/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/bucket_size.pass.cpp b/test/std/containers/unord/unord.set/bucket_size.pass.cpp
index 10dc099ea..e37e047af 100644
--- a/test/std/containers/unord/unord.set/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/clear.pass.cpp b/test/std/containers/unord/unord.set/clear.pass.cpp
index 2f2239129..abaaec3e2 100644
--- a/test/std/containers/unord/unord.set/clear.pass.cpp
+++ b/test/std/containers/unord/unord.set/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/count.pass.cpp b/test/std/containers/unord/unord.set/count.pass.cpp
index 18cac7cf9..97694684d 100644
--- a/test/std/containers/unord/unord.set/count.pass.cpp
+++ b/test/std/containers/unord/unord.set/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
index 647e30b80..ef58e2561 100644
--- a/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
index 4c303194c..10692fa49 100644
--- a/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
index 9dbd43d2f..e3a04f6a9 100644
--- a/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
index 1212321fe..57dfda6fc 100644
--- a/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/emplace.pass.cpp b/test/std/containers/unord/unord.set/emplace.pass.cpp
index c09ad1505..32e6e3487 100644
--- a/test/std/containers/unord/unord.set/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.set/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/emplace_hint.pass.cpp b/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
index 16f9eff19..1bab8d9c3 100644
--- a/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/empty.fail.cpp b/test/std/containers/unord/unord.set/empty.fail.cpp
index 23603c261..f683f23a7 100644
--- a/test/std/containers/unord/unord.set/empty.fail.cpp
+++ b/test/std/containers/unord/unord.set/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/empty.pass.cpp b/test/std/containers/unord/unord.set/empty.pass.cpp
index de28cb256..3656e60c0 100644
--- a/test/std/containers/unord/unord.set/empty.pass.cpp
+++ b/test/std/containers/unord/unord.set/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/eq.pass.cpp b/test/std/containers/unord/unord.set/eq.pass.cpp
index 8ff4ac5df..82737f1ba 100644
--- a/test/std/containers/unord/unord.set/eq.pass.cpp
+++ b/test/std/containers/unord/unord.set/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/equal_range_const.pass.cpp b/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
index 9fa4129c3..587971b74 100644
--- a/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
index c6a42acea..923c1764d 100644
--- a/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
index b584dbb2b..84f4f81d1 100644
--- a/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_if.pass.cpp b/test/std/containers/unord/unord.set/erase_if.pass.cpp
index e060fda1f..2b5f8f6c8 100644
--- a/test/std/containers/unord/unord.set/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
index 231152d14..3bf6282cc 100644
--- a/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
index 06d61db01..34f8a6076 100644
--- a/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
index 92c77f556..bcf3df82b 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
index d60665896..1a222d91b 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
index f7ff42621..83cc5d558 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
index 6cde216f4..218d50137 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_key.pass.cpp b/test/std/containers/unord/unord.set/erase_key.pass.cpp
index ea0323ba2..ea80e2d01 100644
--- a/test/std/containers/unord/unord.set/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/erase_range.pass.cpp b/test/std/containers/unord/unord.set/erase_range.pass.cpp
index ca8250c1e..11908637b 100644
--- a/test/std/containers/unord/unord.set/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/extract_iterator.pass.cpp b/test/std/containers/unord/unord.set/extract_iterator.pass.cpp
index 40feb0e2f..e03e11ff6 100644
--- a/test/std/containers/unord/unord.set/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.set/extract_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/extract_key.pass.cpp b/test/std/containers/unord/unord.set/extract_key.pass.cpp
index f686342b2..9a6123714 100644
--- a/test/std/containers/unord/unord.set/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.set/extract_key.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/find_const.pass.cpp b/test/std/containers/unord/unord.set/find_const.pass.cpp
index bd4542c87..e46e3d5f1 100644
--- a/test/std/containers/unord/unord.set/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/find_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/find_non_const.pass.cpp b/test/std/containers/unord/unord.set/find_non_const.pass.cpp
index 4c81fc60a..bbd37754e 100644
--- a/test/std/containers/unord/unord.set/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/find_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/incomplete.pass.cpp b/test/std/containers/unord/unord.set/incomplete.pass.cpp
index 4f7a00c99..12c95353c 100644
--- a/test/std/containers/unord/unord.set/incomplete.pass.cpp
+++ b/test/std/containers/unord/unord.set/incomplete.pass.cpp
@@ -2,10 +2,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
index e85e94538..fffd108a7 100644
--- a/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
index 712176ede..820ac6e90 100644
--- a/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
index 50f0f6bc8..3ca654764 100644
--- a/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
index 676c39527..f4a38dcfb 100644
--- a/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_init.pass.cpp b/test/std/containers/unord/unord.set/insert_init.pass.cpp
index c106fed10..2af3d3732 100644
--- a/test/std/containers/unord/unord.set/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_node_type.pass.cpp b/test/std/containers/unord/unord.set/insert_node_type.pass.cpp
index 6c91b5393..8eed65865 100644
--- a/test/std/containers/unord/unord.set/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_node_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
index 626f27271..bf8c12776 100644
--- a/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_range.pass.cpp b/test/std/containers/unord/unord.set/insert_range.pass.cpp
index 41b2c0e14..d0c4d7e85 100644
--- a/test/std/containers/unord/unord.set/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
index 45b168d89..75342b7c3 100644
--- a/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/iterators.fail.cpp b/test/std/containers/unord/unord.set/iterators.fail.cpp
index 2bb180b6e..8ded4e023 100644
--- a/test/std/containers/unord/unord.set/iterators.fail.cpp
+++ b/test/std/containers/unord/unord.set/iterators.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/iterators.pass.cpp b/test/std/containers/unord/unord.set/iterators.pass.cpp
index 9c780e109..73b1a4c54 100644
--- a/test/std/containers/unord/unord.set/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.set/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/load_factor.pass.cpp b/test/std/containers/unord/unord.set/load_factor.pass.cpp
index 94eb5d1bd..06d17dc90 100644
--- a/test/std/containers/unord/unord.set/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.set/load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/local_iterators.fail.cpp b/test/std/containers/unord/unord.set/local_iterators.fail.cpp
index eb671a442..b7c3d9b6b 100644
--- a/test/std/containers/unord/unord.set/local_iterators.fail.cpp
+++ b/test/std/containers/unord/unord.set/local_iterators.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/local_iterators.pass.cpp b/test/std/containers/unord/unord.set/local_iterators.pass.cpp
index 55c80e4cb..0797c1ec8 100644
--- a/test/std/containers/unord/unord.set/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.set/local_iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
index dab13ea5a..88471bbaf 100644
--- a/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/max_load_factor.pass.cpp b/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
index e9e04bca8..35028a827 100644
--- a/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/max_size.pass.cpp b/test/std/containers/unord/unord.set/max_size.pass.cpp
index eb695ae97..5ec2af75b 100644
--- a/test/std/containers/unord/unord.set/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/merge.pass.cpp b/test/std/containers/unord/unord.set/merge.pass.cpp
index 519d7f138..91dd476d4 100644
--- a/test/std/containers/unord/unord.set/merge.pass.cpp
+++ b/test/std/containers/unord/unord.set/merge.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/rehash.pass.cpp b/test/std/containers/unord/unord.set/rehash.pass.cpp
index dc3adccc6..c373b1632 100644
--- a/test/std/containers/unord/unord.set/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.set/rehash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/reserve.pass.cpp b/test/std/containers/unord/unord.set/reserve.pass.cpp
index c48a72560..a852f1022 100644
--- a/test/std/containers/unord/unord.set/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.set/reserve.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/size.pass.cpp b/test/std/containers/unord/unord.set/size.pass.cpp
index c127ddf26..e3e488461 100644
--- a/test/std/containers/unord/unord.set/size.pass.cpp
+++ b/test/std/containers/unord/unord.set/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/swap_member.pass.cpp b/test/std/containers/unord/unord.set/swap_member.pass.cpp
index 597662112..9c34e8de9 100644
--- a/test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/types.pass.cpp b/test/std/containers/unord/unord.set/types.pass.cpp
index fdda2b807..7beafedc2 100644
--- a/test/std/containers/unord/unord.set/types.pass.cpp
+++ b/test/std/containers/unord/unord.set/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
index 9cd03809d..d6e604d72 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
index cf473a930..083ebda3f 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
index 4e0f68c71..515022124 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
index f89c45caf..9c8d055a9 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
index 411731479..21cd61458 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
index 06dcc552d..652f2e4a4 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
index 538e34960..800f4f36a 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
index caa4bef02..52cda0692 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
index b8d06dbfd..533c10df4 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
index 4c10ed2d6..7041c8263 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
index da368a154..0ddae6671 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
index ff46e08f4..1550727d8 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
index 0ca9b4857..54b6fbd71 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
index 45ed588a7..d7330c3bd 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
index 8ace22a58..1741320bc 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
index 4fd50a818..ac1369169 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
index 0910bf15f..0bbf312bd 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
index bcd10b077..03567db22 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
index 670a3484d..c91d972f3 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
index 43e06bd50..86a058b07 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
index b6ad0e2a1..182ce8bee 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
index 8900cafc4..0c90055eb 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
index 315ded7a0..3805b7f32 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
index 3f5c829f7..3fc872236 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
index f0d063d2c..8d73e92db 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
index b1ee87f8f..4ed509633 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
index 5b5e861cd..d63770529 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
index 5c77839ff..4ded899f6 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
index db49bd0e7..36f104dfb 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
index 3958ce467..bb14b27a9 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
index 2e8250ef7..5ea0aa38f 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
index 7187f94a2..61371306e 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
index 9ca2f80f0..aad68658a 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/views/span.cons/array.fail.cpp b/test/std/containers/views/span.cons/array.fail.cpp
index e1e5deea5..7e9d85dcd 100644
--- a/test/std/containers/views/span.cons/array.fail.cpp
+++ b/test/std/containers/views/span.cons/array.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/array.pass.cpp b/test/std/containers/views/span.cons/array.pass.cpp
index 72a86654e..d9d1029b6 100644
--- a/test/std/containers/views/span.cons/array.pass.cpp
+++ b/test/std/containers/views/span.cons/array.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/assign.pass.cpp b/test/std/containers/views/span.cons/assign.pass.cpp
index cb2100461..ea6028ad0 100644
--- a/test/std/containers/views/span.cons/assign.pass.cpp
+++ b/test/std/containers/views/span.cons/assign.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/container.fail.cpp b/test/std/containers/views/span.cons/container.fail.cpp
index c8f6830fb..202e6848c 100644
--- a/test/std/containers/views/span.cons/container.fail.cpp
+++ b/test/std/containers/views/span.cons/container.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/container.pass.cpp b/test/std/containers/views/span.cons/container.pass.cpp
index 401f41e07..8bd5f613d 100644
--- a/test/std/containers/views/span.cons/container.pass.cpp
+++ b/test/std/containers/views/span.cons/container.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/copy.pass.cpp b/test/std/containers/views/span.cons/copy.pass.cpp
index c123acb6a..1ccb679ce 100644
--- a/test/std/containers/views/span.cons/copy.pass.cpp
+++ b/test/std/containers/views/span.cons/copy.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/deduct.pass.cpp b/test/std/containers/views/span.cons/deduct.pass.cpp
index 098215c83..7c5338836 100644
--- a/test/std/containers/views/span.cons/deduct.pass.cpp
+++ b/test/std/containers/views/span.cons/deduct.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/default.fail.cpp b/test/std/containers/views/span.cons/default.fail.cpp
index 813939f39..309f7180c 100644
--- a/test/std/containers/views/span.cons/default.fail.cpp
+++ b/test/std/containers/views/span.cons/default.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/default.pass.cpp b/test/std/containers/views/span.cons/default.pass.cpp
index b7d01c9e2..431b7e90b 100644
--- a/test/std/containers/views/span.cons/default.pass.cpp
+++ b/test/std/containers/views/span.cons/default.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/ptr_len.fail.cpp b/test/std/containers/views/span.cons/ptr_len.fail.cpp
index 9ab87f541..ad63c69b3 100644
--- a/test/std/containers/views/span.cons/ptr_len.fail.cpp
+++ b/test/std/containers/views/span.cons/ptr_len.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/ptr_len.pass.cpp b/test/std/containers/views/span.cons/ptr_len.pass.cpp
index c4e9545e9..a1a93c71f 100644
--- a/test/std/containers/views/span.cons/ptr_len.pass.cpp
+++ b/test/std/containers/views/span.cons/ptr_len.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/ptr_ptr.fail.cpp b/test/std/containers/views/span.cons/ptr_ptr.fail.cpp
index bd4dbab8f..0bda60c3f 100644
--- a/test/std/containers/views/span.cons/ptr_ptr.fail.cpp
+++ b/test/std/containers/views/span.cons/ptr_ptr.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/ptr_ptr.pass.cpp b/test/std/containers/views/span.cons/ptr_ptr.pass.cpp
index c2bceec48..1d693e392 100644
--- a/test/std/containers/views/span.cons/ptr_ptr.pass.cpp
+++ b/test/std/containers/views/span.cons/ptr_ptr.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/span.fail.cpp b/test/std/containers/views/span.cons/span.fail.cpp
index 69e879e2e..132d1b152 100644
--- a/test/std/containers/views/span.cons/span.fail.cpp
+++ b/test/std/containers/views/span.cons/span.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/span.pass.cpp b/test/std/containers/views/span.cons/span.pass.cpp
index 5fdbab227..8ace94f5e 100644
--- a/test/std/containers/views/span.cons/span.pass.cpp
+++ b/test/std/containers/views/span.cons/span.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.cons/stdarray.pass.cpp b/test/std/containers/views/span.cons/stdarray.pass.cpp
index 27623a4c9..a0b37fe8e 100644
--- a/test/std/containers/views/span.cons/stdarray.pass.cpp
+++ b/test/std/containers/views/span.cons/stdarray.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.elem/data.pass.cpp b/test/std/containers/views/span.elem/data.pass.cpp
index ceb2eca17..ca49eb890 100644
--- a/test/std/containers/views/span.elem/data.pass.cpp
+++ b/test/std/containers/views/span.elem/data.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.elem/op_idx.pass.cpp b/test/std/containers/views/span.elem/op_idx.pass.cpp
index 801eca428..d11032673 100644
--- a/test/std/containers/views/span.elem/op_idx.pass.cpp
+++ b/test/std/containers/views/span.elem/op_idx.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.iterators/begin.pass.cpp b/test/std/containers/views/span.iterators/begin.pass.cpp
index cd8d70958..0abae63ff 100644
--- a/test/std/containers/views/span.iterators/begin.pass.cpp
+++ b/test/std/containers/views/span.iterators/begin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.iterators/end.pass.cpp b/test/std/containers/views/span.iterators/end.pass.cpp
index 54ff8ebf7..a834804d1 100644
--- a/test/std/containers/views/span.iterators/end.pass.cpp
+++ b/test/std/containers/views/span.iterators/end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.iterators/rbegin.pass.cpp b/test/std/containers/views/span.iterators/rbegin.pass.cpp
index 258908d6c..66e1d5ebf 100644
--- a/test/std/containers/views/span.iterators/rbegin.pass.cpp
+++ b/test/std/containers/views/span.iterators/rbegin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.iterators/rend.pass.cpp b/test/std/containers/views/span.iterators/rend.pass.cpp
index 367ea8866..7c53cb0be 100644
--- a/test/std/containers/views/span.iterators/rend.pass.cpp
+++ b/test/std/containers/views/span.iterators/rend.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.objectrep/as_bytes.pass.cpp b/test/std/containers/views/span.objectrep/as_bytes.pass.cpp
index e4a240f8d..989b6dc5c 100644
--- a/test/std/containers/views/span.objectrep/as_bytes.pass.cpp
+++ b/test/std/containers/views/span.objectrep/as_bytes.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp b/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
index 63d79c923..9b0034b9b 100644
--- a/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
+++ b/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp b/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
index 54216c297..6538a5946 100644
--- a/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
+++ b/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.obs/empty.pass.cpp b/test/std/containers/views/span.obs/empty.pass.cpp
index 23e55bb76..e0cdb141b 100644
--- a/test/std/containers/views/span.obs/empty.pass.cpp
+++ b/test/std/containers/views/span.obs/empty.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.obs/size.pass.cpp b/test/std/containers/views/span.obs/size.pass.cpp
index 16f1b6a7e..0dc1dd268 100644
--- a/test/std/containers/views/span.obs/size.pass.cpp
+++ b/test/std/containers/views/span.obs/size.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.obs/size_bytes.pass.cpp b/test/std/containers/views/span.obs/size_bytes.pass.cpp
index 3b6c5b0e2..fa26a408f 100644
--- a/test/std/containers/views/span.obs/size_bytes.pass.cpp
+++ b/test/std/containers/views/span.obs/size_bytes.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.sub/first.pass.cpp b/test/std/containers/views/span.sub/first.pass.cpp
index e745fd77d..7d6688428 100644
--- a/test/std/containers/views/span.sub/first.pass.cpp
+++ b/test/std/containers/views/span.sub/first.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.sub/last.pass.cpp b/test/std/containers/views/span.sub/last.pass.cpp
index 94d41430b..171556047 100644
--- a/test/std/containers/views/span.sub/last.pass.cpp
+++ b/test/std/containers/views/span.sub/last.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/span.sub/subspan.pass.cpp b/test/std/containers/views/span.sub/subspan.pass.cpp
index 012fc2b5f..22446adbb 100644
--- a/test/std/containers/views/span.sub/subspan.pass.cpp
+++ b/test/std/containers/views/span.sub/subspan.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/containers/views/types.pass.cpp b/test/std/containers/views/types.pass.cpp
index c519fbf76..e8ddbed16 100644
--- a/test/std/containers/views/types.pass.cpp
+++ b/test/std/containers/views/types.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===------------------------------ span ---------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/A.h b/test/std/depr/depr.auto.ptr/auto.ptr/A.h
index cc16abe06..102624dfe 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/A.h
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/A.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/AB.h b/test/std/depr/depr.auto.ptr/auto.ptr/AB.h
index b7ec9882a..6e270b49f 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/AB.h
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/AB.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
index 88f0904ab..1b2d9043f 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
index a5d52a6ef..a8899e103 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
index d5f38c1e2..9e7505acd 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
index cce3c79ef..eccfad4cb 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
index be95d2c19..c3abdf010 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
index b83c266fb..5704f8db0 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
index 78423e518..9efb9cdb6 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
index 10a432647..6c9c476cd 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
index 54eb162f0..7e75911ff 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
index 3dfd200fa..400126e4a 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
index 91801efac..0b5b9c5da 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
index e08df6437..2e08decfa 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
index 572e5e686..554ce3165 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
index cd9fed2fb..bcb7d61c9 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
index 305cf025c..c10beec79 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
index 7174b27fb..271b4ffb4 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
index 650da2ef8..2cd0faf27 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
index 55772b688..c74cabf79 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
index 1895828af..36e59dd0f 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp b/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/assert_h.pass.cpp b/test/std/depr/depr.c.headers/assert_h.pass.cpp
index 39a73467d..aee59570a 100644
--- a/test/std/depr/depr.c.headers/assert_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/assert_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/ciso646.pass.cpp b/test/std/depr/depr.c.headers/ciso646.pass.cpp
index 6a686dc0c..2f962bc8b 100644
--- a/test/std/depr/depr.c.headers/ciso646.pass.cpp
+++ b/test/std/depr/depr.c.headers/ciso646.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/complex.h.pass.cpp b/test/std/depr/depr.c.headers/complex.h.pass.cpp
index 4effd9653..6502bb669 100644
--- a/test/std/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/std/depr/depr.c.headers/complex.h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/ctype_h.pass.cpp b/test/std/depr/depr.c.headers/ctype_h.pass.cpp
index 042084e98..7c7c83a83 100644
--- a/test/std/depr/depr.c.headers/ctype_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/ctype_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/errno_h.pass.cpp b/test/std/depr/depr.c.headers/errno_h.pass.cpp
index 4d955a5b4..51ad3fe7c 100644
--- a/test/std/depr/depr.c.headers/errno_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/errno_h.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/fenv_h.pass.cpp b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
index 0da4c9d86..b6c2549b5 100644
--- a/test/std/depr/depr.c.headers/fenv_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/depr/depr.c.headers/float_h.pass.cpp b/test/std/depr/depr.c.headers/float_h.pass.cpp
index 84e89c4db..3e73b385d 100644
--- a/test/std/depr/depr.c.headers/float_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/float_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/inttypes_h.pass.cpp b/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
index 5b0bb3bff..6db3a42f1 100644
--- a/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/iso646_h.pass.cpp b/test/std/depr/depr.c.headers/iso646_h.pass.cpp
index b40a4e06c..dee560858 100644
--- a/test/std/depr/depr.c.headers/iso646_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/iso646_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/limits_h.pass.cpp b/test/std/depr/depr.c.headers/limits_h.pass.cpp
index 3b78a835d..a8ad39215 100644
--- a/test/std/depr/depr.c.headers/limits_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/limits_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/locale_h.pass.cpp b/test/std/depr/depr.c.headers/locale_h.pass.cpp
index f5735b6ea..9774dd6e8 100644
--- a/test/std/depr/depr.c.headers/locale_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/locale_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/math_h.pass.cpp b/test/std/depr/depr.c.headers/math_h.pass.cpp
index e8341a07f..562597106 100644
--- a/test/std/depr/depr.c.headers/math_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/math_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/setjmp_h.pass.cpp b/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
index 9663d8892..3c8584b1b 100644
--- a/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/signal_h.pass.cpp b/test/std/depr/depr.c.headers/signal_h.pass.cpp
index 83f45c9b1..e2fc456e4 100644
--- a/test/std/depr/depr.c.headers/signal_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/signal_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/stdarg_h.pass.cpp b/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
index e3c38801e..a336fe59f 100644
--- a/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/stdbool_h.pass.cpp b/test/std/depr/depr.c.headers/stdbool_h.pass.cpp
index cd4d4c4b2..38dfc6d84 100644
--- a/test/std/depr/depr.c.headers/stdbool_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdbool_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/stddef_h.pass.cpp b/test/std/depr/depr.c.headers/stddef_h.pass.cpp
index 68f70b80e..8c420de52 100644
--- a/test/std/depr/depr.c.headers/stddef_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stddef_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/stdint_h.pass.cpp b/test/std/depr/depr.c.headers/stdint_h.pass.cpp
index 3d49111fd..e031e2103 100644
--- a/test/std/depr/depr.c.headers/stdint_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdint_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/stdio_h.pass.cpp b/test/std/depr/depr.c.headers/stdio_h.pass.cpp
index 36c37a3be..b60279696 100644
--- a/test/std/depr/depr.c.headers/stdio_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdio_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/stdlib_h.pass.cpp b/test/std/depr/depr.c.headers/stdlib_h.pass.cpp
index cc566d069..c035cf046 100644
--- a/test/std/depr/depr.c.headers/stdlib_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdlib_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/string_h.pass.cpp b/test/std/depr/depr.c.headers/string_h.pass.cpp
index db0308b7e..62c552b9b 100644
--- a/test/std/depr/depr.c.headers/string_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/string_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
index 91727b6cc..e9c480605 100644
--- a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/time_h.pass.cpp b/test/std/depr/depr.c.headers/time_h.pass.cpp
index a2639383c..eb9565128 100644
--- a/test/std/depr/depr.c.headers/time_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/time_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/uchar_h.pass.cpp b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
index be4ea0dae..bff39d2c8 100644
--- a/test/std/depr/depr.c.headers/uchar_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/depr/depr.c.headers/wchar_h.pass.cpp b/test/std/depr/depr.c.headers/wchar_h.pass.cpp
index f2e42a328..607215995 100644
--- a/test/std/depr/depr.c.headers/wchar_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/wchar_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.c.headers/wctype_h.pass.cpp b/test/std/depr/depr.c.headers/wctype_h.pass.cpp
index ad3107100..f4dc1bf4f 100644
--- a/test/std/depr/depr.c.headers/wctype_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/wctype_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
index fc37c9a59..062bbaee8 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
index e47731a65..8d099e52c 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
index 687a819a3..cc3bb6dcf 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
index 2d713b3be..e039fb4c6 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
index 2d2321936..3efe3db56 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
index 65f2a8d34..323a55981 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
index 202abe25e..d1ad26362 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
index 5628c026c..1bffccff5 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
index c77ecf92f..86cc02ec3 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
index 4693c816c..f4a73e753 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
index 24b86f542..4f1e0aa70 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
index 9f0b605d9..6f89ec180 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
index b89aeb8cc..903e13c97 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
index 65fc8c07e..6e6c60d60 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
index bb583aa37..242c977a2 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
index 71588fa1f..f4a78729e 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
index db4606adb..93322099d 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
index 22f44c65c..5f05821c8 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
index cce5c4427..44eee11be 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
index 267b80681..55586a91f 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
index 85ee737d8..eac582062 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
index 6f80993cb..3654ec2f1 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
index 5bce7099c..824cdf9ad 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
index 01945fc46..2814dccf8 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
index 523a2a612..d54896c55 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
index f3c12973f..e1bbb65d6 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
index 9b7101f58..c4f9dcb4e 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
index 30f3c9422..d5261e211 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
index 2713b2f8d..653ea2147 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
index 0b63bb76d..416c20856 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
index 22e7fd6b9..3d77237a2 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
index 79895c4b4..8403d471d 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
index 6f85dae41..4eaa53eee 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
index 8a6a8b943..6ceff9257 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
index b881cb71f..2a73da49e 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
index 142b16a6b..19c4dca9e 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
index 62e8daed1..0717a41b9 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
index 5af028b39..0fac15b3d 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
index b2d6db84c..25c3ce85f 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
index c33e2f7d7..36205d11b 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
index 0ae3b00d2..affa79636 100644
--- a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
index ededc5376..c0be3d8a5 100644
--- a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp b/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.ios.members/io_state.pass.cpp b/test/std/depr/depr.ios.members/io_state.pass.cpp
index 6b362d016..080620599 100644
--- a/test/std/depr/depr.ios.members/io_state.pass.cpp
+++ b/test/std/depr/depr.ios.members/io_state.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.ios.members/open_mode.pass.cpp b/test/std/depr/depr.ios.members/open_mode.pass.cpp
index cf91e7c9d..b8088f651 100644
--- a/test/std/depr/depr.ios.members/open_mode.pass.cpp
+++ b/test/std/depr/depr.ios.members/open_mode.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.ios.members/seek_dir.pass.cpp b/test/std/depr/depr.ios.members/seek_dir.pass.cpp
index 0dd70c101..6c808cb71 100644
--- a/test/std/depr/depr.ios.members/seek_dir.pass.cpp
+++ b/test/std/depr/depr.ios.members/seek_dir.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.ios.members/streamoff.pass.cpp b/test/std/depr/depr.ios.members/streamoff.pass.cpp
index 0c237b354..66200175c 100644
--- a/test/std/depr/depr.ios.members/streamoff.pass.cpp
+++ b/test/std/depr/depr.ios.members/streamoff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.ios.members/streampos.pass.cpp b/test/std/depr/depr.ios.members/streampos.pass.cpp
index 863905f71..7af7c97e2 100644
--- a/test/std/depr/depr.ios.members/streampos.pass.cpp
+++ b/test/std/depr/depr.ios.members/streampos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
index 652f53181..b06816a22 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
index 796e4ad87..e9fc7b39c 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
index 95cf150cc..eca83a007 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
index cbf1dbf9f..a7f19fe98 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
index 8f57eba4d..3ee4154b9 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
index 480148b76..18d4df48d 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
index c49334fa0..adecc53bd 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
index 3dfb1f02d..3671d8244 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp b/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.lib.binders/test_func.h b/test/std/depr/depr.lib.binders/test_func.h
index 1c1a46774..57a208196 100644
--- a/test/std/depr/depr.lib.binders/test_func.h
+++ b/test/std/depr/depr.lib.binders/test_func.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
index 078d8911d..9cce2a3d8 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
index 8b4ae722f..6cf4b621b 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
index 23068f5fd..b73bf32c9 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
index ff797e092..914212031 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
index 0c273b346..66de73a57 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
index deb43d6f6..f4b91c97a 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
index 4e158c6f0..94c2a4885 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
index b6519de8e..edece7db0 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
index 29debf187..96417da11 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
index a60c7cba6..817597168 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
index 4a752d659..a592848ed 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
index b8a23b227..547dde064 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
index 9a7160f45..c9f3e8dc0 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
index 88ab272a7..b394f8326 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
index 1dc03b8aa..0a5429646 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
index 6298fcac3..a1251ae58 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
index 4adb179b3..f02e71324 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
index 473433885..8fd137ea6 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
index 18b6350d5..56624f2b2 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
index 5c273dc45..e780e843f 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
index 67ea32432..81979d0af 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
index 04eaab5ad..e9003c9e6 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
index 1bac82d30..c5acd63a0 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
index 13ae427a1..d38b8d3c8 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
index 3a09711c0..03dc3056e 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
index e466d50c6..997e6707c 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
index 1e5635e46..49da5b262 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
index 289b61f43..5d419f7a4 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
index b0920f7a7..6a7467dec 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
index 9572ef30d..d798eb308 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
index 652100c97..7d98f8cfd 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
index d96f0f769..901dc4a9c 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
index 27de56f2c..933b6306e 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
index 843450b71..0e5f6a7e6 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
index 2a3fe202e..8364ab7ff 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
index 27d5d29db..9b5ba9ada 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
index d412479d8..f888a4d88 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
index 99eb9e93a..85c308ad5 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
index 1b16a37aa..a28d943d9 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
index c4a1562bf..755916f65 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp b/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
+++ b/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp b/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
index 5c596da5a..0974b2ee9 100644
--- a/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
+++ b/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp b/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
index 9b9d726f7..f46d1d4ee 100644
--- a/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
+++ b/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp b/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
index f6bc5bc5a..549f8e0a5 100644
--- a/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
+++ b/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp b/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
index 92d4d38e2..883aa9237 100644
--- a/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
+++ b/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/depr/nothing_to_do.pass.cpp b/test/std/depr/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/depr/nothing_to_do.pass.cpp
+++ b/test/std/depr/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/assertions/cassert.pass.cpp b/test/std/diagnostics/assertions/cassert.pass.cpp
index 3f886e7b9..fe54e1852 100644
--- a/test/std/diagnostics/assertions/cassert.pass.cpp
+++ b/test/std/diagnostics/assertions/cassert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp b/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/errno/cerrno.pass.cpp b/test/std/diagnostics/errno/cerrno.pass.cpp
index 72c9371d1..100e5b30b 100644
--- a/test/std/diagnostics/errno/cerrno.pass.cpp
+++ b/test/std/diagnostics/errno/cerrno.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/nothing_to_do.pass.cpp b/test/std/diagnostics/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/diagnostics/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp b/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
index 5769d2505..14ded723f 100644
--- a/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp b/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
index e360275a6..bcdfe477b 100644
--- a/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp b/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
index 3a9144121..754f79061 100644
--- a/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp b/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
index 3c3d4f4f9..279ac7345 100644
--- a/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp b/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
index f358d2b76..8f5a8f2f8 100644
--- a/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp b/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
index 47f75eb0f..0e576290d 100644
--- a/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp b/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
index 8c82a9189..211c53d12 100644
--- a/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp b/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
index 2b2fe20c6..dae3371cd 100644
--- a/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp b/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
index 103c290ac..f2588576a 100644
--- a/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/errc.pass.cpp b/test/std/diagnostics/syserr/errc.pass.cpp
index 247e10bf8..0738264af 100644
--- a/test/std/diagnostics/syserr/errc.pass.cpp
+++ b/test/std/diagnostics/syserr/errc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
index a74bd2f6b..2b1416e15 100644
--- a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
index 1321dcc6b..8398c70fe 100644
--- a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
index e2e7aeda8..425406ade 100644
--- a/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
index 82770fb43..8aa7fedf6 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
index f6a97ef92..8e5bda762 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
index bec5e630a..abe0c3687 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
index 707604e48..9b9a1acc0 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
index e74458f3f..615c9a0be 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
index cd76a9f5e..73967e90f 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
index c9c6d52e2..78d3a3ef0 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
index 79162ddaa..b75b6b924 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
index dd5182712..870822cbc 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
index d26541d94..89eb8b475 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
index d7cf844df..76cc19838 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
index 0100b1c77..50f48e170 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
index 569681b75..9d7fbba1d 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
index 56489bb71..99d8f9407 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
index 6c073c9fd..aa99f4b3a 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
index 967692a4f..2c06d4b93 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
index 83faa03d2..523562c8e 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
index 01abc42b3..98f46eea6 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
index fc4e0f2b2..7917de06e 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
index 09c87e5ce..0828c1fb8 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
index 8a9a1a232..6b9838ca7 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
index 0b2002401..da226788c 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
index f2e50cf65..a2a9ef717 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
index 0a67cd5db..e7119a3e6 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
index 530f42ca9..7482914e6 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
index 1047b7d42..5e15e0630 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
index 6c76a2552..c5f8650d2 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
index fbc03f1aa..34c3af883 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
index a430ee2f7..e30392010 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
index f3b9eada7..82b0de8b6 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
index 3773872c7..0cefa6e32 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
index 8fcfcc360..44ff3f67e 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
index 509a8b981..9dd5bf303 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
index 7ab063853..ce5768751 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
index acefc4655..6f64e49bf 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
index edeca06d3..8684393df 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
index fd3e69856..d5bbc94b3 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
index 6a60f50f4..c5fc8c60a 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
index c75567312..03038e1c8 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
index 62539ab3e..f6376d523 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp b/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
index f1b460575..6be7b4e9c 100644
--- a/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
index dac13bdb8..0158f3ff3 100644
--- a/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
index eef37c68b..d651e6d5c 100644
--- a/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
index c059ba325..4d59735fe 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
index cd8e3fefb..c2b229a9d 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
index b891a6d97..adca00d1e 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
index acf6387fc..d77d20cfe 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
index 4f697016c..789fed6b6 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
index 87814b190..29df242f0 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/algorithms/alg.search/search.pass.cpp b/test/std/experimental/algorithms/alg.search/search.pass.cpp
index 126f7c8a8..4faa6549e 100644
--- a/test/std/experimental/algorithms/alg.search/search.pass.cpp
+++ b/test/std/experimental/algorithms/alg.search/search.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp b/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
index c82d558c1..6c216bd20 100644
--- a/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
+++ b/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp b/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
index 77ae7b098..5e1920f89 100644
--- a/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
+++ b/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
index ae1b64222..21780ab80 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
index 68c786bc7..c1546706e 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
index fe03fa081..0614cb987 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
index c80ef7968..12ab20cdd 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
index cbf9b41d5..0cd6174af 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
index e2d34df82..0fe8420a5 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
index eaa5233d6..916660c1e 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
index 4e961ec9e..3cdac5ffd 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
index 4eaf3a870..524bba17d 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
index a2f690d7b..a4d0b0730 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
index 7798a6e73..3bf33c808 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
index 21f50a397..a827f3d2a 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp b/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
+++ b/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/header.functional.synop/includes.pass.cpp b/test/std/experimental/func/header.functional.synop/includes.pass.cpp
index 1b72d4a7a..805d8c8fd 100644
--- a/test/std/experimental/func/header.functional.synop/includes.pass.cpp
+++ b/test/std/experimental/func/header.functional.synop/includes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/func/nothing_to_do.pass.cpp b/test/std/experimental/func/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/experimental/func/nothing_to_do.pass.cpp
+++ b/test/std/experimental/func/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/iterator/nothing_to_do.pass.cpp b/test/std/experimental/iterator/nothing_to_do.pass.cpp
index 892d6895a..85149549f 100644
--- a/test/std/experimental/iterator/nothing_to_do.pass.cpp
+++ b/test/std/experimental/iterator/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
index 0bae57e1b..869af67bc 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
index a8c1b286f..b8e98b904 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
index 87ab1e271..674f2863d 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
index e3872c3e0..69d2258b1 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
index 87b493e63..e7210ac72 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
index 794346d75..d9661510b 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
index 30081fc3a..997864881 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
index 278ea9d06..8b205ab89 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
index e92adf033..428b2e4b0 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
index 240d93245..39c279fe8 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
index 0cd3d05c2..da14b4b60 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
index be5174dd3..84fa9314d 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
index aba5eb663..6559ad52d 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
index 1c87b9443..9e9490a3e 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
index 636d5da4e..e856ca12e 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
index 342232962..59c20b849 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
index 030e7af07..eabf03ef0 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
index f996886c4..87e182e03 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
index df3337c4c..693e0518f 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
index 21c05e2be..85d84a435 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
index 844d34cc4..a2214ba10 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
index e26f333aa..b06dac41b 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
index b10e72082..93ac47196 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
index 9c2f39238..2ff459417 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
index b8606317a..a5ec20756 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
index 12ab92ff3..ea30b8977 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
index 77070cc5a..4358f6700 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
index 83c9da66d..62fe61a31 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
index c92e26184..e885358d2 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
index 1fdf2c855..18e96b680 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
index e3c965303..1b7bdd161 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
index ae0a950dc..567f438da 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/language.support/support.coroutines/includes.pass.cpp b/test/std/experimental/language.support/support.coroutines/includes.pass.cpp
index b30d8c7ed..8fc7b4cc8 100644
--- a/test/std/experimental/language.support/support.coroutines/includes.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/includes.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
index c4309d909..885137e76 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
index ba3710d4d..1500f641d 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
index b696d0c13..acec1a02d 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
index 19d9646ad..0e963117d 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
index aadfbcc32..c0a685615 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
index d4aea1cf5..84672d3b3 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
index 7b9b1d385..7ce6ec1fc 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
index a7efad115..a489e865c 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
index 2b4359475..66a072fb2 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
index 666d8f780..16309d662 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
index 9e316991c..91e96cf39 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
index f2f7712a4..d6fa37b84 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
index 27807c1f4..f043c301e 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
index 7dc8f3aac..dc19ae170 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
index a619194fe..adfe683e2 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
index d60c2f2d9..8dadb1773 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
index 5d907660d..75c04c53c 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
index b59606b9e..11d392f59 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
index 353fcafed..7c7c07d52 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
index 86bf8cc11..98c4bdd4f 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
index 86bf8cc11..98c4bdd4f 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
index 4de30bccb..09249219f 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
index f3ecc98ee..df54ba503 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
index 4abc69f0b..5550e4fa5 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
index 16b726975..b2dc3aae1 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
index ff4b3179a..baa8e17c5 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
index 898543fbc..a47968e90 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
index 5654a785a..80e3c6e2e 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
index e834be391..5fc71fb9a 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
index a53b528e8..3a13f1303 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
index 4996d4e6d..507aaf7b7 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
index f371c8a52..ffc6f4239 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
index 3af1d7005..42b6f33eb 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
index 21889c2da..081466dbc 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
index 99c928b7a..190cfd40f 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
index d427fe7c4..7a795d08f 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
index 7dfd3b820..ea8d11e14 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
index 7aa16ab50..91a9027a2 100644
--- a/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
index 412e3323d..958490d78 100644
--- a/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
index f263df30e..aab29728f 100644
--- a/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/construct.fail.cpp b/test/std/experimental/memory/memory.resource/construct.fail.cpp
index d990714ac..d23f58350 100644
--- a/test/std/experimental/memory/memory.resource/construct.fail.cpp
+++ b/test/std/experimental/memory/memory.resource/construct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
index 0ccdeed3c..774e6c7e7 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
index ede1bfdf9..c9ce39138 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
index 86bf8cc11..98c4bdd4f 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
index 8cce9d293..15db1b365 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
index efb529b3c..77aa1da3c 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
index d1a4ab2b8..c76036811 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
index 9e1d28618..db9156834 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
index 32792cf86..e2ff9d9d1 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/memory/nothing_to_do.pass.cpp b/test/std/experimental/memory/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/experimental/memory/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/nothing_to_do.pass.cpp b/test/std/experimental/nothing_to_do.pass.cpp
index 86bf8cc11..98c4bdd4f 100644
--- a/test/std/experimental/nothing_to_do.pass.cpp
+++ b/test/std/experimental/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp b/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
index dd8436618..a17e96df6 100644
--- a/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
+++ b/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.access/default.pass.cpp b/test/std/experimental/simd/simd.access/default.pass.cpp
index d799675a9..9b179f2c7 100644
--- a/test/std/experimental/simd/simd.access/default.pass.cpp
+++ b/test/std/experimental/simd/simd.access/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp b/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
index d15f138d5..7f70c5b02 100644
--- a/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
+++ b/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp b/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
index b73466477..a01e42358 100644
--- a/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
+++ b/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.cons/broadcast.pass.cpp b/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
index 49b2b5572..2e34bb9ac 100644
--- a/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.cons/default.pass.cpp b/test/std/experimental/simd/simd.cons/default.pass.cpp
index 0f12eced0..2e64a8219 100644
--- a/test/std/experimental/simd/simd.cons/default.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.cons/generator.pass.cpp b/test/std/experimental/simd/simd.cons/generator.pass.cpp
index 43273e896..542715de6 100644
--- a/test/std/experimental/simd/simd.cons/generator.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/generator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.cons/load.pass.cpp b/test/std/experimental/simd/simd.cons/load.pass.cpp
index 8c87fe7a5..3056e47fd 100644
--- a/test/std/experimental/simd/simd.cons/load.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/load.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.mem/load.pass.cpp b/test/std/experimental/simd/simd.mem/load.pass.cpp
index b1a3a2b1d..9bda07ee9 100644
--- a/test/std/experimental/simd/simd.mem/load.pass.cpp
+++ b/test/std/experimental/simd/simd.mem/load.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.mem/store.pass.cpp b/test/std/experimental/simd/simd.mem/store.pass.cpp
index 2025a79f2..3faf40000 100644
--- a/test/std/experimental/simd/simd.mem/store.pass.cpp
+++ b/test/std/experimental/simd/simd.mem/store.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp b/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
index b3cd92add..a2206780f 100644
--- a/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp b/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
index e87eafbdb..f07fca829 100644
--- a/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.traits/is_simd.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
index 8d7c0946c..46326ab5f 100644
--- a/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
index ecb68fb62..d91d906ca 100644
--- a/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
index 736802443..5346afef5 100644
--- a/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
index dffdb7885..658bf0c12 100644
--- a/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
index 333047511..7d3304fbc 100644
--- a/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
index ab4a54b7f..24c9d7011 100644
--- a/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
index c654a6a07..a6252b245 100644
--- a/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
index b09763a59..c888d436b 100644
--- a/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/nothing_to_do.pass.cpp b/test/std/experimental/utilities/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/experimental/utilities/nothing_to_do.pass.cpp
+++ b/test/std/experimental/utilities/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
index 33826383d..481fd4f8f 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
index 6de6c63d6..7a0fb47eb 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
index ae6ef08d3..9b6e70458 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
index e4051325f..d46180ee6 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
index b112b078d..3aff45980 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
index 282f0aee6..5fe39a435 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
index 743fc8eac..b99a25121 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
index 10b0dd896..10dc724ab 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
index 8ba5261de..ec0ad47e7 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
index ca65f3c47..0320161ba 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
index b021cbd5e..aa4f1a3ed 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
index ee104a525..77f8791a3 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
index daefdf320..0e992a69b 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
index 6a7289b2f..45a3bd363 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
index 9c6ed89f6..b9f6bad69 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
index 0e46f91cf..6badeeede 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
index 5e9e0434f..8dffebafa 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
index 808eda0e3..53d378391 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
index 298389b7b..04fe4add1 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
index 810e86eea..d8ea66e8d 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
index 6bdf76c92..87b688909 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
index 292335449..c0a5e1e44 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
index b9b6b3f90..b7dd8f843 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
index 8029ff474..f424fae64 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
index 4ceea8a1d..14ba32387 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
index 1ac6d254a..8c0cb02fc 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
index c5c832bbe..e6b94957f 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
index 488738d32..76c683458 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
index d54222a97..40f4ae7d5 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
index fb8e1282f..f019f07d1 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
index 29a1868d6..8f0e0d8cd 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
index 074a3914a..584f52ba6 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
index a2082ec5c..4eb25db29 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
index 20756d984..52eadc4b3 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
index a4a28b48a..696330a42 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
index 4b5b42467..8c214f745 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
@@ -1,9 +1,8 @@
 //>==---------------------------------------------------------------------->==//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //>==---------------------------------------------------------------------->==//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
index 3865b9370..fb6799785 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
@@ -1,9 +1,8 @@
 //>=---------------------------------------------------------------------->=//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //>=---------------------------------------------------------------------->=//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
index 3ac12c27f..a1d5b3d9e 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
@@ -1,9 +1,8 @@
 //<==----------------------------------------------------------------------<==//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //<==----------------------------------------------------------------------<==//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
index 42b2730c5..00bf157d9 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
@@ -1,9 +1,8 @@
 //<=----------------------------------------------------------------------<=//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //<=----------------------------------------------------------------------<=//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
index 1104abdec..ba30912dd 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
index 6c3b60948..1df35dd88 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp b/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
index 7ac96d250..9c3ac0cc9 100644
--- a/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
+++ b/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp b/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
index 2583d4345..45140f333 100644
--- a/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
+++ b/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp b/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
index ab2f15e95..675c57516 100644
--- a/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
+++ b/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/c.files/cstdio.pass.cpp b/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
index 1f1b0c3fa..95a5cb695 100644
--- a/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
+++ b/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/c.files/gets.fail.cpp b/test/std/input.output/file.streams/c.files/gets.fail.cpp
index 064d72cd9..0772dc9f0 100644
--- a/test/std/input.output/file.streams/c.files/gets.fail.cpp
+++ b/test/std/input.output/file.streams/c.files/gets.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
index 86844343e..b6890b871 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
index 66409543f..0acda35b0 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
index 084d00103..6fd1d2bb4 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
index f4fbbf69e..d9230b045 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
index 96806fbfe..ad4d37dad 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
index 02e2b607e..7f7ce344f 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
index 9d2d56782..fc3dd6d01 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
index 042fe03d4..0aeb505c7 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
index 3ac505e52..e711b0c9b 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
index d2780c627..9126b3396 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
index 3c9c0d35d..8859b0796 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
index 5d77e0054..e0c95f50a 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
index 949ea50d0..312a68d83 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
index b143bd4a5..4ee860a8e 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
index 4ff84f26c..5a2d826be 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
index cfd5a031f..ede9fd239 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
index 556cc858a..a213cc643 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
index d9b4a8ccb..f63ae6bdd 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
index 06a6b7794..07a6a4113 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
index 4b0819f8a..36546035c 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
index 0e4bc7177..818f73be8 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
index 69cbf3f5c..d6722076a 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
index 231bb82c7..07f5c18f5 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
index 182f12c47..4bc436b38 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
index d83983269..ecbc15bc3 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
index 6ced241f7..3f81e18f4 100644
--- a/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
index 18443cedb..e30a9c060 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
index 36fa29a4e..9ccd54eec 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
index 5700720a0..c008fe50f 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
index 41e6780e8..896903d36 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
index eeb06e0e5..c7e389e3a 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
index 99eae3a28..7d6da5b27 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
index ef3959cfc..6e0bb2984 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
index d4155ea8e..a0d90e255 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
index 3e3933240..609ca4ac1 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
index 82f7c64eb..4432ea5c6 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
index 47dc85fac..3a12c9852 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
index 619694e27..e6759ed8c 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
index 53fd294e7..ea64139f1 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
index dd39eee1a..a3b441f93 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
index 95224774c..89e32e97f 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
index 094f55073..1eba0d576 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
index 31f2153eb..4190db3a6 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
index f8308ab06..f87bb1e79 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
index fe885cf40..85fcffee4 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
index 9a23384b0..bad7e4f64 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
index 60f925690..5e4a18d1e 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
index b95db6626..41e739abb 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
index b8c358d8e..00a704191 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
index 867998bb7..857b6c68f 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
index e5cddc9e1..689622741 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
index d54aa1824..6a223891a 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
index d707e0a32..6e8f2fc36 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
index 243994add..1feb4214a 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/file.streams/nothing_to_do.pass.cpp b/test/std/input.output/file.streams/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/file.streams/nothing_to_do.pass.cpp
+++ b/test/std/input.output/file.streams/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy.pass.cpp
index a81d5ea79..717c766b9 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy_assign.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy_assign.pass.cpp
index 204207276..4040933e9 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy_assign.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
index 1d83cc69d..106eb033f 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
index 240541d20..856231243 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move.pass.cpp
index 238a8549e..f4c7e44e9 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move_assign.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move_assign.pass.cpp
index f104980c9..38107da07 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move_assign.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp
index b06bd1293..aac7f76cb 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp
index d19c8c2ad..b2240ed76 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp
index 575f0d59b..859763b91 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp
index 4a9b76d63..e8ecdee32 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
index 7df36fed3..10e8c63b6 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp
index 04dec92c9..f61222bbb 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp
index 2a0d80ca6..036c87939 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp
index 17124c132..e89ccf9ec 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp
index afdd47a51..8427fd181 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
index 2abb13df1..185b0ef4a 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp
index ec654468b..2a59cdb18 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp
index e8850c3a7..55821af5e 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp
index ac224ac7a..99da0c9ff 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp
index 3f08e4024..6dd81f291 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
index 0a33544c5..8cbea9dfc 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
index 21c4ed3b7..c318bdb33 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp
index a641e9237..71f7b2ada 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp
index a2bf2ac9f..7870d73b7 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp
index 1c7224344..2e41740ae 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp
index 1aa177505..2fd6abe29 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
index 4619083e8..bac693903 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp b/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
index 6676c7b7d..53c619bd8 100644
--- a/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
+++ b/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp b/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
index 4cbf2062a..38573beac 100644
--- a/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
+++ b/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp b/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
index 89739b77d..676ceea8d 100644
--- a/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
+++ b/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp b/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
index b7484df5c..075a4137d 100644
--- a/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
+++ b/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp b/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
index b7a0383e0..de1e413be 100644
--- a/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
index a02ef18c4..fb74c8e19 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
index fe677c3e6..eb45c0981 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
index a0575e649..04b8f63cb 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
index 71fa47d1b..12422c68e 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
index 92eff6e07..edc0b2638 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
index 2be6122a0..41efb7513 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
index 03d5134fe..842d70543 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
index 69bdb7415..789789779 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
index aa4b03e9b..203c0e5ee 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
index 2e8cce228..4382de141 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
index 39d63f456..b10d3aa88 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp b/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
index 1a722d7a2..481ffcde6 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
index 4eb15cd0b..aa511cdf0 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
index 3e2fdd08d..4d295eec5 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
index f4e1d2f74..96fa1597b 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
index 93c49a6ab..7cb81ca00 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
index d41ab619a..2e33769cd 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
index fca642647..a224dddfa 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
index ec914b1bc..43393aba5 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
index b4019e7f2..42191379d 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
index c118b8714..70040c48a 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
index 07cd32772..363535221 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
index eecfe4252..ac623dbfc 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
index e035764d2..3f2fac696 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
index bb0f58cab..0d747b188 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
index ca02b8680..14feaf13e 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
index 4f5f77df4..53fdcc160 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
index 744ad4df8..86453f8d0 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
index be662fcb1..d82578850 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
index e0b3a959c..7b5082c8f 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
index 2a291d61d..2c7042e9b 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
index 00eafe532..287e31523 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
index 28867432c..3728db5f2 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
index b03b8008b..6cf310be8 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
index 96b8286d5..54d0799d9 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
index 7902289ed..375e45da8 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
index 65be19fdc..2072a9450 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
index 554b5129c..66d854f00 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.path/synop.pass.cpp b/test/std/input.output/filesystems/class.path/synop.pass.cpp
index 875f92fb6..9b91651e0 100644
--- a/test/std/input.output/filesystems/class.path/synop.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/synop.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp
index 40ce491b7..9179908a6 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp
index 00c8c35fc..de97832c4 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
index e02d6679c..114285e8f 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp
index 9b239c6bf..47b344a7f 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp
index 799494f1b..a24559c68 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
index 2d30cc3b8..ea9f4de5d 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp
index e258c45e3..c203106d8 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp
index 61bb8724b..7a41ada56 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp
index fe6ce5ff3..2cf363821 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp
index 662c11446..1ffe664ca 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp
index 9807309f4..91f20717a 100644
--- a/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp
+++ b/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
index 75477309f..25f63a92b 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
index db40f6de9..54574f720 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
index 899ab6820..d2162d083 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
index d4ec48e84..fc11e8a9c 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
index 5af504530..117c35875 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
index 9f2e4e214..e043c87e5 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp b/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp b/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
index 157083a30..6606c9a27 100644
--- a/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
+++ b/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.pass.cpp
index b2a5794a5..2f06fd165 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.pass.cpp
index eb10d9816..7717c261e 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp
index ba579d0af..c791a7436 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp
index a67b431fb..90da3b535 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp
index 61733d526..f419039fa 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp
index ee4a9ed4b..e687ee5de 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp
index 6b651dfb0..c7a72038a 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp
index e73e21ffb..f512a30ef 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp
index f013bbb20..796b7a72a 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp
index f1d9ff041..e4bf09074 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp
index f1ffc74c2..b645ccbc2 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp
index e69aae186..a2658a51e 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.pass.cpp
index dd3736e08..41136a7a9 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
index 392f66c6d..ebe4fc67b 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp
index 916052b74..2ae1c41e6 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.pass.cpp
index 60e0042cf..3d597b046 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp
index 2e9704a3d..55527c908 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp
index 36f1d6bbd..fbfb62c0e 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp
index b0c3fe542..e011dce07 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp
index bb578b9cf..049129834 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
index cd4dd1748..8a8fc50f6 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp
index 3c86dc0e7..8cf036dfd 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.pass.cpp
index a2134c7c1..fb7107060 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp
index 0c3488635..55d97f2e2 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp
index 7273c6c2e..f0d894c99 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp
index e1ac98a80..8d1723571 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
index bf0096acf..5e26e8e10 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.pass.cpp
index b5fb838dd..434fcea1d 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp
index ec4fc6d91..a7c498434 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp
index 43dfec834..488738eb5 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp
index 940f886f9..fd9bac796 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp
index 37b47f151..3fb20524a 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp
index 0f015c387..523ce5f06 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.pass.cpp
index e2ebdc61f..8373d67b8 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp
index 1a2df47e6..43ce5b060 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.pass.cpp
index 2c2e75af6..7bb6c55fa 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.pass.cpp
index ab72f2e5d..93444bb00 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.pass.cpp
index d74ced643..93a251c84 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp
index fac630da1..a4d883dba 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp
index 523e429cf..fbce59168 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
index 0fe058ffd..c655490ac 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp b/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
index 071fa800c..aa1933cc6 100644
--- a/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
+++ b/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp b/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
index c61bb2e12..e3030995d 100644
--- a/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
+++ b/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp b/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
index 557de3488..96ba646ff 100644
--- a/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
+++ b/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/input.output.general/nothing_to_do.pass.cpp b/test/std/input.output/input.output.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/input.output.general/nothing_to_do.pass.cpp
+++ b/test/std/input.output/input.output.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp b/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
index 34b65f52d..0a68da1c4 100644
--- a/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp b/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
index 7c653f348..05ed05c39 100644
--- a/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
index 92b6c726e..0dffdfb5f 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
index 915efd081..7dcbcf488 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
index f4d425728..b9505c76e 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
index cf6c8ae68..f53411270 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
index e8fd00c7a..2dc91457c 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
index dacc8d26d..bf6fe65ba 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
index 6890f1cf7..ef7dcd24e 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
index beaebfe85..570aeaa39 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
index 1c8716e86..6a285556d 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
index f5ef23e65..da93a3baf 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
index 8d1261137..f683bee45 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
index 4b4765452..0c8eee50d 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
index cc70faed6..2fff174cb 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
index c37e17516..6529ad333 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
index eda490f8d..3c8a0783f 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
index 22a760da6..bc28ec29b 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
index 6f1091690..8bbb636e6 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
index eb8a7231f..5635339a8 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
index 1db250ed4..402d3eab0 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
index 78fdc6638..cedd6a6c8 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
index 0d4516d55..fadc70943 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
index b5068220c..51e0aab1a 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
index d4cb2bb13..31023cca8 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
index 4c3aef491..36ea25daf 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
index a02fe2c51..293cd8b45 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
index b815246d6..55db22bce 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
index 5afc56d8a..dbc6e2398 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
index 8f19cea7b..17aff9fd8 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
index 1e98b7dfd..1873d70fb 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
index 82e460db9..cc06149b3 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
index 3c8159a6d..a1ab81a95 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
index 230a59a88..cd46b14fd 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
index 0f356e26d..b73a2fe72 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
index cf06e343b..86189b260 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
index 83fd40bef..ca2827aa0 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
index 8b42bae55..efaf168d6 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
index 0a48393e0..35495ef95 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
index c6368b44a..514cd2e7f 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
index f17aa1623..5fa822cd1 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
index 5c6a3c59f..1cd19c0e1 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
index 9510961a4..99f35aac4 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
index 3095712b9..f2f895d9c 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
index 4264849a0..99b2b6934 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
index 3564d710b..2088e4d14 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
index 20e70cfbd..962aa8c03 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
index 01eecb5d8..5cfd028cc 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
index dc4e0ba0d..b5e1955a7 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
index 3b7417ab2..d7607b62e 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
index 61db67cd5..10bc991aa 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
index 799b46b97..7f87cada9 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
index adf0a6117..c982f79cb 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
index a0734b801..8e8b16600 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
index 18887b75d..cc418fd4f 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
index c5721f211..c26ad292b 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
index 6e00f3993..7bf3d6619 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
index 74ed57dae..71008f7d0 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
index 910b36931..29fed345a 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
index 36cc2029d..07e2f5558 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostream.format/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
index 8214d6c05..f322a8145 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
index 1b58a9a52..a121cd8a5 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
index 7d225d495..155889de7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
index 7929e1845..ea4542be2 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
index 00332f773..e472c6266 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
index 1ee2c565a..f18d9361a 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
index db64b6603..041195d0e 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
index 5e601a90c..4657c98f9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
index 125c0800a..cf0184997 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
index 4b235f405..cedef6121 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
index 44b189d50..20b23b80b 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
index c23b3028c..c101b3cfc 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
index 54c8a2838..7d51a4ddd 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
index a8bdaba86..837efd6f3 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
index 06b6e5c62..8e022edad 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
index e6070ef91..2d6b0be02 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
index 7f8cf4608..636c87146 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
index 59be66fb6..44313251e 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
index 6508f2dab..16b33f3a9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
index 26bfd89dc..cb7f0d62f 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
index 1f05684b5..a07edba5d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
index 0fe2c352e..6e926d10f 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
index f5e8ad40d..23874768f 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
index 09784c034..f5647e1a9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
index 2e40cf406..ff4e85eb9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
index 8ed0bfbdb..ab3e9b580 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
index e3ff0470a..36b9586b8 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
index 32c044d72..95609a264 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
index 199c5dfd9..ef7e6166e 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
index 9d45af0fd..1d2056250 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
index 21260d364..763be3a83 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
index d4516d2f8..ab39c28aa 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
index e510825b6..5668185b0 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
index 9e8a5c8f0..c6a7d9218 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
index f37270150..20703864b 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
index 088826c3d..8ad82cb3a 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
index f04d468ad..7b7890abd 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
index bed0d72af..f48ed92b8 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
index eb76cbf9d..130528046 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
index 10a229d38..a93032b20 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
index 97791f4c7..f07af7471 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
index 87a94ed42..4dc251751 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
index 71f9ad66b..4b804a501 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
index 41ce0346c..dbdb52ee7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
index 991fdfb35..f7d78537e 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
index d351c565e..ab67442d7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
index 8f07742c6..c39c08087 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
index 5a8369c2c..d7b33cdf2 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
index 9c0d3366c..257826b7d 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp b/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
index b0b3c31f7..82ef40c9a 100644
--- a/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp b/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
index 0a2fb36ec..83d4960c4 100644
--- a/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp b/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
index e8600972d..cc548b37d 100644
--- a/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp b/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
index 11532711a..f4bf9e7f4 100644
--- a/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp b/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
index e04677fa3..eef401c63 100644
--- a/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.format/std.manip/setw.pass.cpp b/test/std/input.output/iostream.format/std.manip/setw.pass.cpp
index 3242bcc94..cd5e3f2b3 100644
--- a/test/std/input.output/iostream.format/std.manip/setw.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setw.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.forward/iosfwd.pass.cpp b/test/std/input.output/iostream.forward/iosfwd.pass.cpp
index 53d12ecfc..1caadd1c0 100644
--- a/test/std/input.output/iostream.forward/iosfwd.pass.cpp
+++ b/test/std/input.output/iostream.forward/iosfwd.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
index cdf53f862..1c046bcf4 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
index 1ce04ffb1..cce1f3eaf 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
index 3812b203a..49fffca42 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
index e5887e162..d470956e2 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
index b05078167..516f3b8c9 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
index 6abd6afa8..862f22034 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
index 61ff5fb50..a6883b257 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
index 6543e0aa5..ec5bb50ec 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
index 1da6d4406..9c4d74dcd 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
index a602e3e94..1b5856608 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
index 1b939d86e..ff30e81af 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
index 47ce6870a..405c98899 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
index 76f8fa12a..20ffe33c4 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
index 9c6ebd9f7..108cffdf9 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
index eb738b492..e6cb51ae1 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
index f9e6513e4..9991be4f9 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
index 958fcb53d..1a958b615 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
index 36b579498..0f49701fb 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
index 701e3de36..d22ca2647 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
index e0d6484c8..ab38ab3d5 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
index d9ec47b79..da742974d 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
index b20137702..00ce003da 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
index 163fc54a1..49a55cb40 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
index 287c89d29..d812aa291 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
index 6e532dedd..7c9060948 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
index f4d541e2f..3de42eabc 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
index e6f334808..12434f5a2 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
index 8f265bc69..821a1f514 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
index 1cad020b0..0fa77cb7a 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
index 59f0bd478..467b885ce 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
index 45115823b..65aca332a 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
index eb737b1a7..dd95b2681 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
index 5dc72b1ed..8937f2585 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
index 44c55118d..0fc162599 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
index 5711b55c7..cc607d945 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
index 9f374598f..6a51484f3 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
index 55c02f38c..64123e5d1 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
index 238593feb..88c292955 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
index 005fb61cc..3d0c80974 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
index 760bfcb26..8e23732f0 100644
--- a/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
index d86059ea6..1bd33e961 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
index 77b433653..08d00c1c0 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
index f5c5aa22b..b5cc96c33 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
index 10dccca85..b1c56ed53 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
index 1c1c8be95..387437290 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
index 0b068e0d4..4c6075674 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
index 3cdb434c4..b1ffc1e96 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
index 7be92e72b..bc5871f92 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
index cc0b3f3f1..c1aa1aaf3 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
index 8852c9b55..65f66cb4b 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
index 2887ca100..559768b94 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
index 71eb23846..6ea816d7d 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
index acccbea2a..d2bb41c4e 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
index 68fdf6859..a1585cd54 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
index 1005df6ef..158c953a4 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
index 4e3faa27c..126431ce2 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
index 3efe910b3..7938a84cf 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
index 64d5a3018..bf6566342 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
index d5158a184..9a6b3233f 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
index d99269be7..1d56d475a 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
index fa9f765bf..a475c3589 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
index 03f89506d..e4f28bfe3 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
index ef534f6d0..151c2244e 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
index d09e2a62e..dde113a91 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
index 6d2fe0691..830dd448e 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/ios/types.pass.cpp b/test/std/input.output/iostreams.base/ios/types.pass.cpp
index 22e33f61f..58165fc44 100644
--- a/test/std/input.output/iostreams.base/ios/types.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp b/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
index 5bba8bd3a..c087871ea 100644
--- a/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
+++ b/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
index 461c77742..a21481398 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
index aa2ca6f27..1073e2522 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
index 08056e8f3..c391ab8c5 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
index cbe03bceb..64351b6b1 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
index 281a59cda..cab0bc258 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
index 5ebfea86f..a4073646c 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
index a93c7b4c2..0517481b8 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
index f764fa6fd..745349d14 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
index 30931bae0..ce9f9f020 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
index f202bc4c8..7f04bbc51 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
index 55bf2648f..8dbb7a1d8 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
index 2920cca83..24afef8b8 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
index 53cfd8171..d84aa3775 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
index ca8cd93f0..de58c17f0 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
index ebc0aab67..f67ddabae 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
index 91608f0f5..bd904ad64 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
index 6e26416c5..97d919801 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
index 5e6911c22..24f8bfca0 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
index e78f5f884..5d24d3d41 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
index 5708038e5..61a7dd29e 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
index 76fac604b..923a6ac75 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
index ddf3a8550..d584d3128 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
index 79ae3b6e2..6cfb73633 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
index 226542614..06f1dd836 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
index 4ea3e448f..b153bc840 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
index 99a33c71c..22bcf5eb9 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
index 1a19e2aa6..cc2a4bc45 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp b/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
index 0e9f1278e..aaa5b871a 100644
--- a/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
+++ b/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp b/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
index 438c51138..670932324 100644
--- a/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp b/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/nothing_to_do.pass.cpp b/test/std/input.output/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/nothing_to_do.pass.cpp
+++ b/test/std/input.output/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp b/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
index 03f6d7d0b..b94714212 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
index 7ca8f37fa..c29899291 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
index 7f57f3cf9..76d47f2a2 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
index 0572a9bbe..9eebf2557 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
index 2c77f25c2..741b71e38 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
index 0b9ddff41..2e14de9d2 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
index 8cf62771e..fae4dd78f 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
index cc1679071..8433a9f31 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
index 95dd2db75..ed1d43a86 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
index 200150639..ea51ac64d 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
index ac6d0cc93..4aa7a8181 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
index c68930cfa..2a48158fd 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
index 1935308de..59804043c 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
index 7f44245e2..830f27282 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
index 2f4aad051..a2546b810 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
index 36a19da85..dcdec61a3 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
index 5ea48c18d..3d04924b1 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
index 4ced690a2..bb865636c 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
index fc1a18fe3..0c1cd4efb 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
index 23867e63f..6ece9aa57 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
index ce25a1919..015a7daa2 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
index 68dcf6eab..74152974c 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
index 47ef93914..92b869d31 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
index 460e4c07e..5811c9019 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
index fa4133a47..12f955360 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
index acaf1e846..b31408e95 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
index d25ae9b21..1d1ee519f 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
index 1bdba0714..2422c52e5 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
index b1f154273..20e785383 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
index 3a10d8a70..1f243e958 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
index dcdd45f5f..ae52b9539 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
index 93dc15401..728697f7c 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/stream.buffers/streambuf/types.pass.cpp b/test/std/input.output/stream.buffers/streambuf/types.pass.cpp
index 919caee36..d6ea963df 100644
--- a/test/std/input.output/stream.buffers/streambuf/types.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
index fc5f2e7e9..cb4644aad 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
index 2a428c5d9..b906db8d5 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
index d72cef160..09b6e4b39 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
index 5d44a50a3..327c4ca12 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
index 0a45b796b..c5b144b09 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
index 977923639..cf3c7d891 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
index 448a6f89b..9b706a535 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/istringstream/types.pass.cpp b/test/std/input.output/string.streams/istringstream/types.pass.cpp
index 349bcae1a..0f256cbbd 100644
--- a/test/std/input.output/string.streams/istringstream/types.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
index 5e24542ab..af5622ee2 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
index 8801001f4..f44b0fba4 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
index c98a2e367..0793fd295 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
index dde1dc719..79e0f614c 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
index 67bfc50cd..569310174 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
index 8b90f72d4..8d64dd5e5 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
index ab277a2ee..d74acf3a5 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/ostringstream/types.pass.cpp b/test/std/input.output/string.streams/ostringstream/types.pass.cpp
index c9cb76378..15e7dc61f 100644
--- a/test/std/input.output/string.streams/ostringstream/types.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
index eaca72454..b5dce8fb9 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
index 716b6afa7..2a469ebb7 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
index dca637d39..5a57f902a 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
index af2cccc96..2121a7a84 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
index 14fd0caa5..70eff7384 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
index eae1b0b87..607d31425 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
index 712e0edd2..baf406b69 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
index 7eec80837..0f8330705 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
index d6adf6964..dfbe2084b 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
index 8ec69cb24..dbe117eaa 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
index 2b809a887..7d687e070 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
index 7130f5b86..99bc75e6c 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
index 3641af239..c32449857 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringbuf/types.pass.cpp b/test/std/input.output/string.streams/stringbuf/types.pass.cpp
index 067a3a29e..29d651fc5 100644
--- a/test/std/input.output/string.streams/stringbuf/types.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
index b8905ade3..571c3dc65 100644
--- a/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
index 436c76c5b..671aee553 100644
--- a/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
index 94de61610..4527cae33 100644
--- a/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
index b87f7eb92..7bc383f9a 100644
--- a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
index 95599dd25..07d3a1dea 100644
--- a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
index 3cce695c4..0332924a6 100644
--- a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
index 3ec11cd9e..3225b273e 100644
--- a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream.members/str.pass.cpp b/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
index 155a262e1..b8fa28ddb 100644
--- a/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/input.output/string.streams/stringstream/types.pass.cpp b/test/std/input.output/string.streams/stringstream/types.pass.cpp
index a89daa144..e05048a2d 100644
--- a/test/std/input.output/string.streams/stringstream/types.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.container/data.pass.cpp b/test/std/iterators/iterator.container/data.pass.cpp
index 12ca91295..ab80c1cf5 100644
--- a/test/std/iterators/iterator.container/data.pass.cpp
+++ b/test/std/iterators/iterator.container/data.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.container/empty.array.fail.cpp b/test/std/iterators/iterator.container/empty.array.fail.cpp
index a5925dee7..1cd16ad9a 100644
--- a/test/std/iterators/iterator.container/empty.array.fail.cpp
+++ b/test/std/iterators/iterator.container/empty.array.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.container/empty.container.fail.cpp b/test/std/iterators/iterator.container/empty.container.fail.cpp
index 1773b53e7..4ac2e1335 100644
--- a/test/std/iterators/iterator.container/empty.container.fail.cpp
+++ b/test/std/iterators/iterator.container/empty.container.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp b/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
index f66575268..dcdd89a31 100644
--- a/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
+++ b/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.container/empty.pass.cpp b/test/std/iterators/iterator.container/empty.pass.cpp
index f6fe2351d..b792e0066 100644
--- a/test/std/iterators/iterator.container/empty.pass.cpp
+++ b/test/std/iterators/iterator.container/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.container/size.pass.cpp b/test/std/iterators/iterator.container/size.pass.cpp
index 6d3bc5128..5b78afa26 100644
--- a/test/std/iterators/iterator.container/size.pass.cpp
+++ b/test/std/iterators/iterator.container/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp b/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
index 26d5c8660..e922a4bfa 100644
--- a/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
index ff1b3e7ea..6382d06c7 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
index 2f16fcb38..86fcfbc58 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
index 1743349a5..ad99aed99 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
index 554445c18..b7d993917 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
index f40754fd9..246aeb5e8 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
index a08f35fe9..774609e1c 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp b/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
index 0fab1aa15..5c5c07d44 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
index 179e5e762..81dca5186 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
index 34f430ff3..1c8d11eb1 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
index 5a8fe6077..3be21c49a 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
index 1630feb25..ebcc30075 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp b/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
index ecda1d146..6d7f64b9a 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
index e11b8e9ba..753f25c66 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
index 19b517c32..ac517dd67 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
index e315b2724..1635850cf 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
index f16a3b74c..da2de4681 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.range/begin-end.fail.cpp b/test/std/iterators/iterator.range/begin-end.fail.cpp
index 18c5943a4..b87b82f27 100644
--- a/test/std/iterators/iterator.range/begin-end.fail.cpp
+++ b/test/std/iterators/iterator.range/begin-end.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.range/begin-end.pass.cpp b/test/std/iterators/iterator.range/begin-end.pass.cpp
index 201dd066b..a55e0b639 100644
--- a/test/std/iterators/iterator.range/begin-end.pass.cpp
+++ b/test/std/iterators/iterator.range/begin-end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp b/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterators.general/gcc_workaround.pass.cpp b/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
index 7578e7182..a6be18d10 100644
--- a/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
+++ b/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/iterators.general/nothing_to_do.pass.cpp b/test/std/iterators/iterators.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/iterators.general/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterators.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
index 5dd49a625..1bdd5ddef 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
index f280adb73..22f16c2eb 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
index c6ff0473f..ccb22b2bd 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
index 2b9f245a0..acb272b4c 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
index d3d1fbbcb..67772dabc 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
index d5df1b7c0..93fe8e5fa 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
index f50f309e6..b7f11e0f7 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
index 30e41407e..6c27ce826 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
index 7aa7f3443..47d384382 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
index 96d5d000d..1ebfd4d3f 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
index 1a148e613..80307cb15 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
index 74892272e..9b642a7d2 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
index e6d6c0760..7aa1d6da6 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
index cdca9bf4b..555b72d79 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
index af880f871..ad032a4dd 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
index 1ff49dde4..bf1bf38ad 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
index c18f84baf..f4cc7c984 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
index 7a7c678ed..c8609efbe 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
index 9f17240a7..ae45c90f3 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
index 7d81a7b72..22448fddd 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
index 08e6ced01..c9a8d1ef6 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
index 01eb35efc..c639a2da1 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
index ad1fa29ac..671d6bd49 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
index 1a926b548..d531e5fe3 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
index 43f28d09b..05ede8a52 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
index e379b3057..9d58fc40c 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
index 99ff9641a..36dfddd7f 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
index 758ef0f21..678522597 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
index 54b79b511..63c3e8ed5 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
index e74be5e24..95ab190f1 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
index 6b4396c83..0af1ff83f 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
index 460636df7..ce0cb93cf 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
index 1b2ce8f0d..f17543335 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
index a365f08f3..1e05a50c7 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
index ddd59a617..e58a57b50 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
index e78082e34..e10962f02 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
index 37034d516..ebe90244e 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
index 5074ee33a..72efc481e 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
index 8e6c827fd..69695e56b 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
index 22d267af9..56b99025e 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
index 36d365194..dae13100d 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
index 404e02cd7..dfd89df80 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
index 188acff69..0b8ea4540 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
index 09a534b66..5832ecbcf 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
index f5f921a77..0b6db37e1 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
index c434b3082..c7c00183c 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
index 4ff511c13..f37522c13 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
index e5d570429..4bcbdd579 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
index bf7a8e33e..d626ff28a 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
index ef87014cd..027162b90 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
index 4c5d816b8..6dfe0a517 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
index 089cc29b2..68fe476ac 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
index 30a95c367..fbc5320fe 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
index a6d4d61e1..9eb4669c3 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
index 88fd0def5..de035fcd3 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
index 3f42f06ee..bbbf1247f 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
index 4bf816d28..47fc29b09 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
index c0a9afecb..02ab54a59 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
index 798f9a805..db53853dc 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
index 4cf82179c..8ad3d79b3 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
index 9c53bbbfe..c67884d91 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
index 7d9edd5b0..2232a87f5 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
index 7e75344ab..d2337e208 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
index c485b0483..eed06f3df 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
index 67ad1ae88..546038213 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
index 5a06ea5ad..35fdf1b1e 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
index 326562476..f0df91777 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
index 5c34417c3..b59095db8 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
index 3bed189dc..a484a67a7 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
index 62ca76495..efe3dbf9c 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
index 18f978012..0580eb098 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
index 59f721838..e39476a98 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
index 1d4d09158..066aa769b 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
index 9ef8c30b4..2c7574eb4 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
index e0e0059ac..d32932848 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
index f0ff828b5..b12f7c135 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
index 4596d6f38..a1b08f65c 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
index 4ff57518d..7e4f27e7a 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
index 9fb6310b9..8934d68ef 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
index 7b829ff6a..ce0b470a6 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
index 00f739d09..25876d072 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
index 292a77787..7242f6a34 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
index fc6dc0009..4ee68b5fc 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
index 452049677..1ffe4dcfe 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
index 937bb8d3a..f569d3206 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
index 12a6f90e8..50b40aba4 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
index 30057a227..a2862b403 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
index e6f86d483..38ffe4bfd 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
index d1824bae6..5ba335c5e 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
index f5c49e379..b32f358cf 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
index 87173f7dc..6a361ff71 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
index 3046ced75..9a7185c1b 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
index c71ee4099..d7e1a31e5 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
index 69e98265e..a7927cbb2 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
index f5a5fa0c6..6b4719cad 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
index 020b4f24b..2b94d8c97 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
index 013766431..9b0034131 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
index 81e5f3439..7e50c68f7 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
index 19fb02fc4..28cb7a93a 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
index 65a78cb10..ede97380b 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
index 2e4f52ce7..15c266d73 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
index cb7960a0e..148bd725a 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
index acaf2f569..2535d9913 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
index c974e2cd0..829d1f0a6 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
index 42c8c3dd9..3521b05fa 100644
--- a/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
index 7dca8b071..255a837e7 100644
--- a/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
index de4c8b0f2..bc99f7a40 100644
--- a/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
index 628e5e901..0f21309ba 100644
--- a/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
index 7fa26171f..457962332 100644
--- a/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
index 8c7543363..8fa2a4e56 100644
--- a/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp b/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
index c1f3e5575..24cf15ff1 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
index 6366355cc..1de0ea2ea 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
index 69c2dfc9b..7b4422f94 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
index cc451c0a2..dea585c3c 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
index 322107528..4d79f7c1d 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
index 00b63e8da..d93aad6cc 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
index 8d043e1e6..716ba2bfd 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
index c46cf4822..0c28a77ac 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
index 1576b7d48..0d2c85bef 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
index 91d7b6927..45e57fc80 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
index d08616410..e33a5a5c8 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
index 64997d382..b52fce813 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
index 7461ce163..c765a5c2d 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
index cdf748465..346d8b849 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp b/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
index f146dace6..4c999637f 100644
--- a/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
+++ b/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp b/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
index 4ea823499..6c51b7a20 100644
--- a/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp b/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
index 07fc26eed..e34cadc55 100644
--- a/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
+++ b/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp b/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
index 94668ab7c..4b75e5d51 100644
--- a/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp b/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
index 375cff460..dae2f2147 100644
--- a/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
+++ b/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp b/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
index 067f378e0..6e9e7d441 100644
--- a/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp b/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
index 20ae6e620..6f46342da 100644
--- a/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
+++ b/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/nothing_to_do.pass.cpp b/test/std/language.support/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/nothing_to_do.pass.cpp
+++ b/test/std/language.support/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/align_val_t.pass.cpp b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
index ffb54ab4d..1b0b4c00b 100644
--- a/test/std/language.support/support.dynamic/align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
index cf8d4af93..713e66245 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
index 50521c000..d2fefdd1b 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
index 0d4524cac..f5681d8d9 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
index 55a3edabf..922ab9db4 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
index 349bf440e..37c477f13 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
index 297fbf861..8500577f9 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
index bb656d8d7..abea113a6 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
index 66a8a5d2c..c47001f54 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
index 71b560c4b..4be67f0f9 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
index d8e08a3a0..40ba48dec 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
index 58ff728e6..8365b053c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
index f29f0c09e..3effc7ea3 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
index 3d8467faa..a28f7f4f1 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
index ad4d9f469..4ea28241c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
index 40632a1bd..482a27e9c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
index f7921d2f2..6183c0c2c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
index 130148786..1f3921909 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
index 43295a7e6..39de421c2 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
index ef9ec2db9..686ef66ba 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
index d0b740545..773a9b992 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
index a988b803d..2d845e601 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
index ab25a9be0..a077fb7ce 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
index ad306e06c..3cd5e1245 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
index 462d1973c..671a3cc05 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
index 61172fb5a..b7b17e196 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
index def8839c4..7b5eb19d9 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
index 1ea014aff..6c5cfcdd1 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
index df002c60a..3c73738d6 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
index 53a7c8e23..c7ddbebed 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
index f165dbf8f..b6a1cfa46 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
index 6762687a5..8a7b9bcf2 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
index 2dd4631e7..d37ca28f0 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
index d85db6c49..6d391645f 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
index a0e3eda57..b4217525f 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
index aa00fee56..300843b2f 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
index 865cb1ee8..5042a8d1e 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
index 410c6d774..e22ea0fdd 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
index 1fe104551..617eeae3c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
index 39392691e..dd51ad54a 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
index d9e0f5ca3..779d7b2ac 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
index 5b08eb4b8..bed5cc232 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
index 178e26db1..9c54750bd 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
index 7d6f34845..be208b431 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp b/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
index 1c75e561d..3f105410b 100644
--- a/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
index 457696a42..c3d227183 100644
--- a/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
index 034c578bb..f8fd12f1c 100644
--- a/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp b/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
index 3baddaa89..c4e1cc7a1 100644
--- a/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
+++ b/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/except.nested/assign.pass.cpp b/test/std/language.support/support.exception/except.nested/assign.pass.cpp
index 6338c8aaa..c03f4bbfd 100644
--- a/test/std/language.support/support.exception/except.nested/assign.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp b/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
index 4cbdbb2ec..cc8c99856 100644
--- a/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp b/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
index 18ca9968f..5aa762cf7 100644
--- a/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
index 43a11bab3..426ea55bf 100644
--- a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
index d511a72f9..ba81b8fe3 100644
--- a/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
index 6a9f25cd0..c0bc423b0 100644
--- a/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp b/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp b/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
index 82ae4aaa8..2ec624ba6 100644
--- a/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp b/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
index c4bff603e..9eae3a45e 100644
--- a/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp b/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
index e477f5298..8f889beee 100644
--- a/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp b/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
index 3199d9b9e..431ad8bf9 100644
--- a/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/exception/exception.pass.cpp b/test/std/language.support/support.exception/exception/exception.pass.cpp
index ad53b6ebf..bfb27418f 100644
--- a/test/std/language.support/support.exception/exception/exception.pass.cpp
+++ b/test/std/language.support/support.exception/exception/exception.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/propagation/current_exception.pass.cpp b/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
index c33d64d06..3c265d8bb 100644
--- a/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp b/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
index 3aa8dcf55..39f2d6014 100644
--- a/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp b/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
index 35821d9bd..3db951d28 100644
--- a/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp b/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
index 37ffb5be5..ab2df72e8 100644
--- a/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp b/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
index a4353be4f..29087eb15 100644
--- a/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
+++ b/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp b/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
index 859d831a3..bab33d837 100644
--- a/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
+++ b/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.general/nothing_to_do.pass.cpp b/test/std/language.support/support.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/support.general/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.initlist/include_cxx03.pass.cpp b/test/std/language.support/support.initlist/include_cxx03.pass.cpp
index 8710ddcdd..343da95f4 100644
--- a/test/std/language.support/support.initlist/include_cxx03.pass.cpp
+++ b/test/std/language.support/support.initlist/include_cxx03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
index cadae24cb..ff532fbf2 100644
--- a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp b/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
index 2d831c9e1..dc5c5ffd4 100644
--- a/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
index abb07dc99..61bf27084 100644
--- a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.initlist/types.pass.cpp b/test/std/language.support/support.initlist/types.pass.cpp
index a301ef924..9aad9b3f7 100644
--- a/test/std/language.support/support.initlist/types.pass.cpp
+++ b/test/std/language.support/support.initlist/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp b/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
index c1e5be91e..ec144a031 100644
--- a/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
+++ b/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/c.limits/climits.pass.cpp b/test/std/language.support/support.limits/c.limits/climits.pass.cpp
index 5e31b494b..317d5d509 100644
--- a/test/std/language.support/support.limits/c.limits/climits.pass.cpp
+++ b/test/std/language.support/support.limits/c.limits/climits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp b/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
index c6731fcc8..6b48dfbc3 100644
--- a/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
+++ b/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/is_specialized.pass.cpp b/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
index ff5c1a2c0..4959d5f54 100644
--- a/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
+++ b/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
index 11772f67d..012a9a8ee 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
index 8a3ca008d..d67e8cbab 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
index 7dec03d08..de9aa3395 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
index 017f8630a..9c2fcfb17 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
index b27f5c583..691bd5b27 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
index 5096ad211..05469f08c 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
index 1b087f0cd..89bc78a48 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
index 1391f2096..abdd9b544 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
index cb5736f5c..a351bcef0 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
index 4f43a6532..bc74464e7 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
index 241f9cc27..924f32a6b 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
index e00afa900..8f2cdb0a7 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
index 8431b733f..2c769d87c 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
index 2e9ac223a..c7edf178d 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
index 6e321d1ef..80a45fa29 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
index f6412a97d..c364fd01b 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
index b7a892605..08dc5eb77 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
index f505f4142..bb6ae168e 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
index 65d5150a7..0bf7237ad 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
index 158e2791f..4b8714875 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
index 649310938..7ce1ac9d7 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
index c4c7a30a7..e2bbdde10 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
index a1e61fcdc..66ddaa474 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
index 930d01102..8fb4f09f6 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
index 05891b1f6..812dd53bb 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
index 5d5597c47..852cf86a1 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
index 1514ae841..8c9e48a2d 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
index 3c2dc5493..f2d962df4 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
index f1fd20035..43e962961 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
index a0a6d7f84..312f69714 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
index 901eea4d0..3e0ad694b 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
index 8e407c225..e71432b18 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
index 6cf5681d8..3c7cefd55 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp b/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp b/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
index d6c70c4cf..c6a01bf66 100644
--- a/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
+++ b/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/nothing_to_do.pass.cpp b/test/std/language.support/support.limits/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/language.support/support.limits/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.limits/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
index 36f82c0b7..57234ad43 100644
--- a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
index dbd27c14b..9bbaca7aa 100644
--- a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
index 9d746ece9..85bda4322 100644
--- a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
index 835e48d0e..3fb2c7ed1 100644
--- a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
index 97d2b9246..6c26e06a0 100644
--- a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp b/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
index f1e252f8e..045dcb8ac 100644
--- a/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
index 3605878c5..9e434c5c2 100644
--- a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
index 13d6b9312..bcc205358 100644
--- a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
index c1dff02d2..2864c9f4e 100644
--- a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
index 170a3da89..c6a9b1648 100644
--- a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
index b21239122..9d9b9bca3 100644
--- a/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
index f4ebc8e10..82a0932d0 100644
--- a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
index a325d6a3a..53a1b3345 100644
--- a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
index 97ce6d330..c27bdc6b0 100644
--- a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
index 2fcd44cd0..476a31ef9 100644
--- a/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
index 990e5683b..6638cdee9 100644
--- a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
index 5bf021307..102cd29ea 100644
--- a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
index 5ca84c1cc..e11464231 100644
--- a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
index c80ebb11e..d019d8fe5 100755
--- a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
+++ b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
@@ -685,10 +685,9 @@ def produce_version_header():
   template="""// -*- C++ -*-
 //===--------------------------- version ----------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
index ef2e05826..bd2ea2417 100644
--- a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
index 77eec86cf..9194ff855 100644
--- a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
index 7312c4de7..b1ad28206 100644
--- a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
index e63df4ff5..bb2005e32 100644
--- a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
index cf087259f..c1159cf73 100644
--- a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
index 352d73637..c5a5b5436 100644
--- a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
index a98bc28c8..c1ecad723 100644
--- a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
index 1d8cb9005..55e595fa9 100644
--- a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
index 857ece267..cb182adc1 100644
--- a/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
index 04edd597b..4986a1f19 100644
--- a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
index e2dd9b774..95a717dfb 100644
--- a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
index 83b620765..f44cbc2c7 100644
--- a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
index 4c9fecd21..59e698d76 100644
--- a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
index 1bcf8d55d..17be75c2e 100644
--- a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
index cd07ac068..412e29c6c 100644
--- a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
index 4c2f35af9..d111f263c 100644
--- a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
index 7a4cabde8..c886850ce 100644
--- a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
index 493411ffd..12c58480b 100644
--- a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
index 8639c468c..0f1c37b90 100644
--- a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
index 44e97f3af..adad6b084 100644
--- a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
index 6466a2f64..e2d986532 100644
--- a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
index 49113a3d0..59994b779 100644
--- a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
index 9aa06e4db..f6f4e6cec 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
index 3153afd25..07a3c302a 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
index 94bdb824a..6b051d289 100644
--- a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
index d4ef3d7e0..23a15a670 100644
--- a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
index 5cdeca06b..c22921e77 100644
--- a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
index 5fa996967..aa409e154 100644
--- a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.limits/version.pass.cpp b/test/std/language.support/support.limits/version.pass.cpp
index c41f492bb..b67df2892 100644
--- a/test/std/language.support/support.limits/version.pass.cpp
+++ b/test/std/language.support/support.limits/version.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp b/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
index 448ffba2c..5f9dc962d 100644
--- a/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
+++ b/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp b/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
index 190aebe54..90b6bc20a 100644
--- a/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
+++ b/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.rtti/type.info/type_info.pass.cpp b/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
index 74c1c0c7d..d0a6a0fd6 100644
--- a/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
+++ b/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp b/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
index c91a21ff2..d519622b7 100644
--- a/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
+++ b/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.runtime/csetjmp.pass.cpp b/test/std/language.support/support.runtime/csetjmp.pass.cpp
index f50603056..dc68bf4a3 100644
--- a/test/std/language.support/support.runtime/csetjmp.pass.cpp
+++ b/test/std/language.support/support.runtime/csetjmp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.runtime/csignal.pass.cpp b/test/std/language.support/support.runtime/csignal.pass.cpp
index a42363f8b..b827236bb 100644
--- a/test/std/language.support/support.runtime/csignal.pass.cpp
+++ b/test/std/language.support/support.runtime/csignal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.runtime/cstdarg.pass.cpp b/test/std/language.support/support.runtime/cstdarg.pass.cpp
index e7282b1c5..b3c919af0 100644
--- a/test/std/language.support/support.runtime/cstdarg.pass.cpp
+++ b/test/std/language.support/support.runtime/cstdarg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.runtime/cstdbool.pass.cpp b/test/std/language.support/support.runtime/cstdbool.pass.cpp
index f52c1556f..98a0e7e49 100644
--- a/test/std/language.support/support.runtime/cstdbool.pass.cpp
+++ b/test/std/language.support/support.runtime/cstdbool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.runtime/cstdlib.pass.cpp b/test/std/language.support/support.runtime/cstdlib.pass.cpp
index 02c8c9fd8..bc2cfcbb4 100644
--- a/test/std/language.support/support.runtime/cstdlib.pass.cpp
+++ b/test/std/language.support/support.runtime/cstdlib.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.runtime/ctime.pass.cpp b/test/std/language.support/support.runtime/ctime.pass.cpp
index d80bc1982..57fb01245 100644
--- a/test/std/language.support/support.runtime/ctime.pass.cpp
+++ b/test/std/language.support/support.runtime/ctime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.start.term/quick_exit.pass.cpp b/test/std/language.support/support.start.term/quick_exit.pass.cpp
index 2bf2ea790..5b7c36b08 100644
--- a/test/std/language.support/support.start.term/quick_exit.pass.cpp
+++ b/test/std/language.support/support.start.term/quick_exit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03
diff --git a/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp b/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
index f42498e3d..c1703f2be 100644
--- a/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
+++ b/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp b/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
index c49704f99..acf10068b 100644
--- a/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
+++ b/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03
diff --git a/test/std/language.support/support.types/byte.pass.cpp b/test/std/language.support/support.types/byte.pass.cpp
index a1abefa84..a4a9e8219 100644
--- a/test/std/language.support/support.types/byte.pass.cpp
+++ b/test/std/language.support/support.types/byte.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/and.assign.pass.cpp b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
index 4aea7909d..e4875d38f 100644
--- a/test/std/language.support/support.types/byteops/and.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/and.pass.cpp b/test/std/language.support/support.types/byteops/and.pass.cpp
index 32c0bdaee..312e679cd 100644
--- a/test/std/language.support/support.types/byteops/and.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp b/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
index 157626137..99660b6b1 100644
--- a/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
+++ b/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
index 66946b464..413b62b1f 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
index 6883dccfb..9fe86883f 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/lshift.fail.cpp b/test/std/language.support/support.types/byteops/lshift.fail.cpp
index c21393591..6d889ed23 100644
--- a/test/std/language.support/support.types/byteops/lshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/lshift.pass.cpp b/test/std/language.support/support.types/byteops/lshift.pass.cpp
index a1731b990..73cc66373 100644
--- a/test/std/language.support/support.types/byteops/lshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/not.pass.cpp b/test/std/language.support/support.types/byteops/not.pass.cpp
index 2629001e9..cb94e3659 100644
--- a/test/std/language.support/support.types/byteops/not.pass.cpp
+++ b/test/std/language.support/support.types/byteops/not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/or.assign.pass.cpp b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
index 0cceeaaec..cad3acef3 100644
--- a/test/std/language.support/support.types/byteops/or.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/or.pass.cpp b/test/std/language.support/support.types/byteops/or.pass.cpp
index 62260f27b..4b778398d 100644
--- a/test/std/language.support/support.types/byteops/or.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
index 80f0bd7bc..dcd656734 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
index 6763995f6..bbb921240 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/rshift.fail.cpp b/test/std/language.support/support.types/byteops/rshift.fail.cpp
index b78af2eb2..1dc5f83cf 100644
--- a/test/std/language.support/support.types/byteops/rshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/rshift.pass.cpp b/test/std/language.support/support.types/byteops/rshift.pass.cpp
index eec3ad683..2ca3c6c20 100644
--- a/test/std/language.support/support.types/byteops/rshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/to_integer.fail.cpp b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
index 86f2ad95b..ea3836b16 100644
--- a/test/std/language.support/support.types/byteops/to_integer.fail.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/to_integer.pass.cpp b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
index 065e6d127..cdae92ac4 100644
--- a/test/std/language.support/support.types/byteops/to_integer.pass.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
index 07727ec9e..8caeec7dc 100644
--- a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/byteops/xor.pass.cpp b/test/std/language.support/support.types/byteops/xor.pass.cpp
index d7e18c91b..1dbf07f36 100644
--- a/test/std/language.support/support.types/byteops/xor.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/max_align_t.pass.cpp b/test/std/language.support/support.types/max_align_t.pass.cpp
index b7fe0ac64..50c4f5ef5 100644
--- a/test/std/language.support/support.types/max_align_t.pass.cpp
+++ b/test/std/language.support/support.types/max_align_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/null.pass.cpp b/test/std/language.support/support.types/null.pass.cpp
index 7e31a8525..ce8530a00 100644
--- a/test/std/language.support/support.types/null.pass.cpp
+++ b/test/std/language.support/support.types/null.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/nullptr_t.pass.cpp b/test/std/language.support/support.types/nullptr_t.pass.cpp
index ffa0c90d4..01a674a0a 100644
--- a/test/std/language.support/support.types/nullptr_t.pass.cpp
+++ b/test/std/language.support/support.types/nullptr_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp b/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
index 92bd87943..e6dc3772b 100644
--- a/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
+++ b/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp b/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
index 34c7a93e4..ab1f447cd 100644
--- a/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
+++ b/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/offsetof.pass.cpp b/test/std/language.support/support.types/offsetof.pass.cpp
index d479f9ca4..4a9dfac5e 100644
--- a/test/std/language.support/support.types/offsetof.pass.cpp
+++ b/test/std/language.support/support.types/offsetof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/ptrdiff_t.pass.cpp b/test/std/language.support/support.types/ptrdiff_t.pass.cpp
index 702ec720a..9c6c36f38 100644
--- a/test/std/language.support/support.types/ptrdiff_t.pass.cpp
+++ b/test/std/language.support/support.types/ptrdiff_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/language.support/support.types/size_t.pass.cpp b/test/std/language.support/support.types/size_t.pass.cpp
index bb3b0805b..ba1f64673 100644
--- a/test/std/language.support/support.types/size_t.pass.cpp
+++ b/test/std/language.support/support.types/size_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/c.locales/clocale.pass.cpp b/test/std/localization/c.locales/clocale.pass.cpp
index 534213495..8217dd74d 100644
--- a/test/std/localization/c.locales/clocale.pass.cpp
+++ b/test/std/localization/c.locales/clocale.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
index dfbdeaea9..33a94f990 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
index df67f432e..21cf03681 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
index 4f738076e..7cd3d0fe5 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
index 7c07c71d1..f00c8fd95 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
index 8f7e2b5f8..ded9ebae3 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
index d2cf3a921..ff5aa4bdd 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
index d8a9650e3..61d5a640f 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
index e78a3c74c..7b8c9915f 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
index fd0b177c8..45957c3be 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
index c260e34e3..92024149c 100644
--- a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
index 9fcedddbd..5ba7a67e4 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
index a1e15ba45..20eef3354 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
index 945de76a7..c4561f796 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
index 74a4906fd..9415d8b5a 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
index dedf6a7d3..b0fa41a2f 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
index 4c5478afd..01bb80534 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
index 9777c9892..3f4f04902 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
index b17662d03..6cd24a82e 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
index f28f4f99b..9d815196b 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
index 1dfc95fe6..2b817002c 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
index 22b27370e..036ed25c6 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
index 2a714b1d5..c393bb91b 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
index 8a842c8df..25af985f7 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
index 5a65a561a..5b9f74bad 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
index c86cc55ce..ab3a838c0 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
index f7b0e5b71..1aef57d3f 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
index be223ce79..b23f9ef83 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
index 24c2f23f0..d5cde4754 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
index 0559896ba..4d2803815 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
index 8eda52def..50bf58349 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
index adaf4e8fb..2379b1631 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
index a2973b7f3..f6b94c5f1 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
index 121a815bf..e12d30168 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
index 5a6cdee9f..e0ed00dfd 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
index fae0d7bb2..56d63764d 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
index 4cd84f243..8f4293ee8 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
index 4a0f94f98..2f84eb6c9 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
index d2a6ae395..4a30c4ee8 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
index 41c26508e..6a883d3d4 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
index bd3482974..a48b902e1 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
index 8abe10b82..69c711f60 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
index 18997714f..9b5d0f988 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
index 9b91a03d4..bde44c088 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
index 2270a308f..2ef1e5c65 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
index 175470a67..834bd6076 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
index f645b32f2..8472a5692 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
index 4455b9f55..6986314e3 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
index 62b4919c5..921ec1854 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
index 05a90d33d..210f8c052 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
index 0a4aa2003..26981d3c8 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
index 71640490e..2590c2b0e 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
index 79bc2bfa5..571ab84d8 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
index 10c9fcdc0..2b7c610e4 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
index c5897c86b..b930009b5 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
index 626c65244..adc0b1707 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
index 17bde6cec..28b4be745 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
index 834fa0f27..56c10aa52 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
index c25607878..2d338dd8e 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
index 258998ff4..df6451747 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
index b7604f33d..ed33018b2 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
index 0412f6fa5..7ca632e4e 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
index 69037aad7..0fcab1af7 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
index 38ce51455..fefd11016 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
index e4cabf6ef..8769b8814 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
index 10ab7a2b8..9241c7a47 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
index 892e89391..12fee2682 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
index 2b4a686cf..b01bd5a7a 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
index c76fea9af..6ad469754 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
index bfec2339f..6c19e41a8 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
index 509e52ab0..32acd85d1 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
index a993466ab..1087b88c0 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
index a09072a98..45d90ddd5 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
index 904ced323..19d751d29 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
index 6f25b9cad..c51b97311 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
index 25b2c3e4e..6c875863f 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
index 270ae1f15..dbeeae4c6 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
index a9a872014..3f9ab9dce 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
index 67fe44931..29021e0f4 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
index 271ae2c03..b9c882c9a 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
index 650713570..2b0669cb3 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
index 0e9909720..9ec946816 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
index 1070fa613..5752bb82b 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
index 9b841b28b..4f5efca1d 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
index 7eb3cc895..e41b93b78 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
index fa82da96b..a48f75f4f 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
index 7084245d9..f348d2080 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
index ad8fb2117..1e1194bda 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
index fcc6cfccd..523fb2503 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
index 535c83078..23718fec1 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
index da21642b9..22bc14701 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
index 6e75ba483..b5c402de2 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
index 68daf8d88..92bbc8ceb 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
index 2a5acd179..0ed6e4504 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
index f0a7ee3d2..0510778eb 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
index 2a8733c20..1737de8f0 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
index 1c656011a..3942268eb 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
index ae3566060..89ac905a2 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
index e82878a31..df42b522c 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
index 6bed5383c..994a97211 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
index cf9b4c899..7f2e4f9b9 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
index 60e47b537..454d9b182 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
index 9052826a5..f70f8eead 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
index 0f034fa4f..94f9bd7a9 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
index ce046e61e..27ae11eed 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
index 5b56ab3e7..b543799ac 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
index 4e62a1bc0..20ba6f491 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
index b9099f4f8..a5cb05334 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
index 2e4fb3242..9ad7528c2 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
index d0a0007ba..bdbb0b6cd 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
index db193eabc..28f7451e9 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
index 2ba29dfff..e9e916a3c 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
index 56fb85058..1894144db 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
index 1036969bb..0a3d478ec 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
index 659f948d6..ab4a5c603 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
index 44ff1073d..27c2ff5d6 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
index c6cab19b2..f66d2c633 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
index e1c616c55..a64388ca5 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
index 724dc1e5c..9bbc76868 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
index f050164b6..7ff50db73 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
index edbaf8600..6cd00de65 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
index 66c8c6424..6857810bd 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
index f401b72d8..ff3cdcdb2 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
index 04cd173dd..50a7ca939 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
index 90fb7193e..e0bfd88a8 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
index 798dbd08b..4717d4c0f 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
index 8dc4726e2..577322425 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
index 66262dc43..206f32535 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
index 0622342ff..b27ecd6df 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
index fc857d658..e959ad8ab 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
index d1df09cdf..e9950b1a7 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
index 1664c5537..3ef5e84fc 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
index 6e28154c5..3c3034bbe 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
index 5ec8d9a54..dbe3e4ba7 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
index 27db562ff..7b24c6dc9 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
index a0c17dcae..d02c3b43e 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
index 8998bf004..439f8c31f 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
index f801e6c5a..afb58d5e2 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
index 4f6f0b47e..0c71a7354 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
index 596f8f80f..0d30bbf70 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
index 1a0a7663d..5cf9bfa1f 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
index cdd163980..5fcc0e464 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
index 55f7d0f9f..18d96754b 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
index 4d8c2af38..f4fdf7620 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
index cfa6382a4..98aba106c 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
index eaf670972..ccebb6ce1 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
index f6f1e5c21..19e8ceeb0 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
index 71af9cdc7..2929fb05e 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
index f2cc2e796..8b4a33e84 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
index e3367b26f..7e896f705 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
index 174312d09..aa7ffcb78 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
index 570b8306c..02f2ba6dc 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
index cf671b000..89fa436a9 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
index 86e64e622..9f8153c6b 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
index c290722f3..2388dce5f 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
index 0665bf2ac..36aafc2f4 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
index 03fa3d777..47b58b34e 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
index dcf4bf199..3518c30a0 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
index 283c8e63d..f83148a1d 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
index ab02716e3..5c6de9709 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
index bb40f31db..4faa4155e 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
index b87b4b99b..ab8c00ede 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
index 963974d11..b779be50f 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
index c44debf35..62ca19784 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
index 2b6ade5c0..5c0a5ff59 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
index ec1e3e7c9..7dd82ed63 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
index 931ab5d40..787d4a00e 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
index 551f298b0..a975bc962 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
index 6cf3b6aef..c63fab2aa 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
index 1e7c170da..6c8d86e12 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
index 8cea95de8..bdb61c66d 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
index 452a35440..b0e8b1c39 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
index 09055add7..342c87a48 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
index 31135a349..c2566095f 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
index 676e7fff8..a53cd059b 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
index 1bdb8de60..93ae51e55 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
index c6c4359e4..a920c5cb9 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
index 264494ba6..e14d1c57f 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
index 6b8bd73be..3f95fd3b4 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
index 4c663a3bc..e7f19a5da 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
index 39a10b48a..22b2825c8 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
index 19e378ce8..e7b86c791 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
index 1761a6d8c..78d32ece4 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
index 05182c288..fb8b49808 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
index b8b05f6dc..c2523dc5d 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
index 679d05840..f78359c91 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
index 918a9026f..f972a63bf 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
index 5212eb12b..3e6e982bd 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
index 6e5e04d25..210112f8e 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
index 9045ecbe5..c046a7de6 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
index f434ea577..ba0dd69e4 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
index 8e79357b5..30f1eef6e 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
index c22980a69..2010ef4ff 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
index 93d595206..24971f48f 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
index d9e7f3cd5..9bef3e787 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
index db9d3fbf4..c638624d0 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
index 0617cdc52..cddc1497e 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
index 1f2aeeabd..c6e67dbfb 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
index b84f3a1c7..7d6978a93 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
index 6ac459698..39d0de277 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
index c89e3f4cc..43385c023 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
index b48005586..7cbf9b43a 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
index f2935ba92..2ce956df7 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
index 19932d654..cc47edbf2 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
index aa426d0fb..96fb3011d 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
index 967a4f4b2..236d9460d 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
index ac35fb852..160594850 100644
--- a/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
index a61a9c928..22be9593b 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
index 0b7d4cbf3..91d95af9a 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
index 2d12d985b..d3fbea6dc 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
index 56d6262d0..e44783564 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
index 463a9fbac..4e6fdf858 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
index 29bb58d56..6422d5679 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
index b90c41e59..afd1e6ad6 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
index 463d2f925..2471ccb19 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
index 5fa0eaaf8..f350b62ca 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
index 963c269fa..167521573 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
index b17752cb0..324546d99 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
index 308bb9da2..4f5d3d8fb 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
index 7239b4c8f..4b5e096af 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
index 70e23f8f5..a353ad6cf 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
index 886fc4416..430b5c254 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
index 1f0c237d0..344b3e503 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
index 7690e6193..6d658624e 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
index bc178800f..a392c8a25 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
index 392d66f22..aab52fdf1 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
index 8f5be81e6..172a8734d 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
index ef4d0b827..247e0ce20 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
index ced2a36a4..846df2156 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
index 2bcade01f..96139bd5b 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locale.syn/nothing_to_do.pass.cpp b/test/std/localization/locale.syn/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locale.syn/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.syn/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
index 376b33460..68b9b9f1b 100644
--- a/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
index d1a0e6912..0e5a777b3 100644
--- a/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp b/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
index 0bd45ac6b..afca98b70 100644
--- a/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
index bdc063286..35a4540fd 100644
--- a/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
index b294aa537..3b4d0c551 100644
--- a/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp b/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
index e131e50b3..057b70226 100644
--- a/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
index a8c39fae9..990fc03eb 100644
--- a/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp b/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
index b606d3262..b9fb94a3c 100644
--- a/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
index 884b30338..b00ba46e6 100644
--- a/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
index 8ce51bc70..c5863beb3 100644
--- a/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
index 340769557..4a77628db 100644
--- a/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
index 6f0994a00..c16755e20 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
index 24706b5a8..66f95df53 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
index bcfb16e05..f268f9a21 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
index ffd813f86..ffd5a0df7 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
index aa9d5e8a9..4494d56c7 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
index aba76df0b..1816ad0c7 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
index 189ec2bdd..c22fb6a14 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
index 9c08a353f..523778f23 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
index 8c66ad141..72b939dfb 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
index 3299a3d00..dbd936529 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
index 480628f70..b52bbc0bb 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
index b56b72fb0..578547f8e 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
index 7651f8ac3..0e58bc225 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
index 72e79dfb1..c1a874dc2 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
index 6d3947fed..364cfed80 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
index 2e627b739..e527f31a1 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
index a7a816b37..0fb5b9f34 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
index 0a6cab73b..2e4dce8bd 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
index d46c858fd..eb67ecffc 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp b/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp b/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
index 58767f059..a895b1aa1 100644
--- a/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
+++ b/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp b/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
index 2dba4b68e..c7f53975d 100644
--- a/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
+++ b/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/assign.pass.cpp b/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
index 8b31a8f97..02b5f1096 100644
--- a/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp b/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
index 7ba64b051..5424a8b92 100644
--- a/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locales/locale/locale.cons/copy.pass.cpp b/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
index 9e446e440..885dfea37 100644
--- a/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/default.pass.cpp b/test/std/localization/locales/locale/locale.cons/default.pass.cpp
index 2bb3c9a80..8f79b1842 100644
--- a/test/std/localization/locales/locale/locale.cons/default.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
index 6a79d3943..d0ccb8a34 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
index 1144931e3..498682f28 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
index 5bf6befed..79db6f044 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
index 946e8b530..5fdde6c67 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.cons/string.pass.cpp b/test/std/localization/locales/locale/locale.cons/string.pass.cpp
index 6fc0808b2..449b9fbc2 100644
--- a/test/std/localization/locales/locale/locale.cons/string.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.members/combine.pass.cpp b/test/std/localization/locales/locale/locale.members/combine.pass.cpp
index a9919f6a8..1a867fbfa 100644
--- a/test/std/localization/locales/locale/locale.members/combine.pass.cpp
+++ b/test/std/localization/locales/locale/locale.members/combine.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.members/name.pass.cpp b/test/std/localization/locales/locale/locale.members/name.pass.cpp
index 13ae27285..3a6e1b98c 100644
--- a/test/std/localization/locales/locale/locale.members/name.pass.cpp
+++ b/test/std/localization/locales/locale/locale.members/name.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.operators/compare.pass.cpp b/test/std/localization/locales/locale/locale.operators/compare.pass.cpp
index 40740520d..b42e55ff6 100644
--- a/test/std/localization/locales/locale/locale.operators/compare.pass.cpp
+++ b/test/std/localization/locales/locale/locale.operators/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.operators/eq.pass.cpp b/test/std/localization/locales/locale/locale.operators/eq.pass.cpp
index c809f49d2..aeb877086 100644
--- a/test/std/localization/locales/locale/locale.operators/eq.pass.cpp
+++ b/test/std/localization/locales/locale/locale.operators/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.statics/classic.pass.cpp b/test/std/localization/locales/locale/locale.statics/classic.pass.cpp
index 078030ce4..9060ae27d 100644
--- a/test/std/localization/locales/locale/locale.statics/classic.pass.cpp
+++ b/test/std/localization/locales/locale/locale.statics/classic.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.statics/global.pass.cpp b/test/std/localization/locales/locale/locale.statics/global.pass.cpp
index d4b115514..961bb2f4c 100644
--- a/test/std/localization/locales/locale/locale.statics/global.pass.cpp
+++ b/test/std/localization/locales/locale/locale.statics/global.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
index dbab8212a..7724ffd00 100644
--- a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp b/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/locale/nothing_to_do.pass.cpp b/test/std/localization/locales/locale/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locales/locale/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/locales/nothing_to_do.pass.cpp b/test/std/localization/locales/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/locales/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/localization/localization.general/nothing_to_do.pass.cpp b/test/std/localization/localization.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/localization/localization.general/nothing_to_do.pass.cpp
+++ b/test/std/localization/localization.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/nothing_to_do.pass.cpp b/test/std/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/nothing_to_do.pass.cpp
+++ b/test/std/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/c.math/cmath.pass.cpp b/test/std/numerics/c.math/cmath.pass.cpp
index b02bdbe64..fa9048643 100644
--- a/test/std/numerics/c.math/cmath.pass.cpp
+++ b/test/std/numerics/c.math/cmath.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/c.math/ctgmath.pass.cpp b/test/std/numerics/c.math/ctgmath.pass.cpp
index 24908ff03..c2ea8e875 100644
--- a/test/std/numerics/c.math/ctgmath.pass.cpp
+++ b/test/std/numerics/c.math/ctgmath.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/c.math/tgmath_h.pass.cpp b/test/std/numerics/c.math/tgmath_h.pass.cpp
index 65fc54ebd..c58827cb4 100644
--- a/test/std/numerics/c.math/tgmath_h.pass.cpp
+++ b/test/std/numerics/c.math/tgmath_h.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp b/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
index f2bf6433c..671e4d12d 100644
--- a/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
+++ b/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/complex.number/cases.h b/test/std/numerics/complex.number/cases.h
index a2f85d11c..6663245d2 100644
--- a/test/std/numerics/complex.number/cases.h
+++ b/test/std/numerics/complex.number/cases.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index 3e215c8bf..4be7122e7 100644
--- a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp b/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
index 6a3ae48d7..0e9a7cefc 100644
--- a/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp b/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
index c649157a8..f05c42f25 100644
--- a/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp b/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
index 6adbf21ec..80bd15714 100644
--- a/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
index b5cffe9c1..8be97fac2 100644
--- a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp b/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
index e847a9413..a3bf9dd27 100644
--- a/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp b/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
index 3b1e9b34b..60a5b1957 100644
--- a/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp b/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
index 60d6e7223..a9dfeae57 100644
--- a/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
index 07ae3ab7a..5d0fa76b3 100644
--- a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
index 8831ca1d6..ed944eb04 100644
--- a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
index 6cc911d4e..0b09858a3 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
index 09a6f270f..25d0d1d44 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
index d11530d78..9fbe5572a 100644
--- a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
index d39429427..8ab5460a0 100644
--- a/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
index 87b78061e..cb9a778c2 100644
--- a/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
index b4200fc81..b1d1288ae 100644
--- a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
index 89907d13a..511140c67 100644
--- a/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
index 67a1c7189..11c5c319d 100644
--- a/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
index ddec891b2..e3d9da7b5 100644
--- a/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
index 9b222b8a1..d108b8a54 100644
--- a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
index 4dd8066d1..b417505fa 100644
--- a/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
index 98b7197cb..1d0469085 100644
--- a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
index c94baa9b6..f32b247c2 100644
--- a/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.members/construct.pass.cpp b/test/std/numerics/complex.number/complex.members/construct.pass.cpp
index 25b9ce62c..75d9b5d67 100644
--- a/test/std/numerics/complex.number/complex.members/construct.pass.cpp
+++ b/test/std/numerics/complex.number/complex.members/construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp b/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
index 8d55fcdb4..b1b378b56 100644
--- a/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
+++ b/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
index 8d4712eec..44837cc09 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
index b23b381cb..ec9af0d21 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
index 59243c7c6..88cee3158 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
index cd6972b9d..e08d85fd1 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
index b2cddd26d..eb93cbe63 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
index b630679fc..0b81ed949 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
index 9c8ffe0b0..4ad67be2c 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
index deb26e2d9..43f0f8c5d 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
index 02ed8684e..46953f662 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
index eeec83fb0..7f4a7a2b5 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index 8ead5bfb6..ba499e51b 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
index 0e829a4ca..94afd4b86 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
index e16f02ea6..e793c7dc9 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
index 777d7d614..551fd2574 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
index 35a374911..b69389827 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
index 6bfffb849..352181476 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
index ec0de5a7f..52ae2a150 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
index ebff8b23b..1e96a3d9c 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp b/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
index 24644e307..e6d944f42 100644
--- a/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp b/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
index edb381cf6..2e72bd8a5 100644
--- a/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp b/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
index 6a3a201ce..c61c8779f 100644
--- a/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp b/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
index 5edaad29e..e6d2de6e4 100644
--- a/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
index ac26e3c9e..9681bdb17 100644
--- a/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp b/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
index 3bb01ac46..db4fb2c4f 100644
--- a/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
index 97c258024..09f2b6ae2 100644
--- a/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp b/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
index 3866f6e33..72031e11e 100644
--- a/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
index 3027d4cdc..e2074cbe3 100644
--- a/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp b/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
index d15197532..66876e0bc 100644
--- a/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
index 515e83dfc..5e56346ec 100644
--- a/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp b/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
index 9401febee..6e9bc5b3a 100644
--- a/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
index 4f24a1c65..3b4ce5839 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
index 8cbd7a8a1..5f967668f 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
index 7930548f9..afbea2a0c 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
index 22b9fd08a..e6d197365 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp b/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
+++ b/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index 837734fcd..76b280af3 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index 5258bdc3a..b981e1a31 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index 8d7462141..7d6516aeb 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index cb9188d93..c6a6d8bb3 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
index 9e2298cf7..f4025ae73 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index 37e00c392..4f037377e 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index be9d505b9..ff069397a 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index dad5bd190..eb6ef8832 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
index 31317816f..9442bb084 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
index 589b59699..98d3cf454 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
index 8eb72006a..299e037a6 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
index 0d039a159..848527792 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
index 36a296221..55120dcd5 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
index 74a3857e9..81b4b2ca7 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index 0ab8ac275..2c2b8cbb9 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index e310f26dc..a2668320f 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index d3273179a..007bf2ac3 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
index f27ead3da..e7c80a309 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index 1028836f9..511cdeefa 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index 7a0e3bd70..8fa09a7ef 100644
--- a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index 78f2781b7..27366ec0e 100644
--- a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
index 71f276d8d..7d6472aa6 100644
--- a/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
index fa7b7339a..d4bf0d8c1 100644
--- a/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index da7ad14be..aeb13c80b 100644
--- a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index 69463ded2..3f7c497c2 100644
--- a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index 1a7e0c53f..6de4a0af8 100644
--- a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
index fbb51f080..a94ba9f14 100644
--- a/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/complex/types.pass.cpp b/test/std/numerics/complex.number/complex/types.pass.cpp
index 4da9a2a90..3b2f3f7b8 100644
--- a/test/std/numerics/complex.number/complex/types.pass.cpp
+++ b/test/std/numerics/complex.number/complex/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/complex.number/layout.pass.cpp b/test/std/numerics/complex.number/layout.pass.cpp
index a9f356d4a..a154f5e40 100644
--- a/test/std/numerics/complex.number/layout.pass.cpp
+++ b/test/std/numerics/complex.number/layout.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/nothing_to_do.pass.cpp b/test/std/numerics/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/nothing_to_do.pass.cpp
+++ b/test/std/numerics/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp b/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp b/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
index 29cc34f07..854b5cb35 100644
--- a/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp b/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
index 931c0d3c7..2faff95c7 100644
--- a/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp b/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp b/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
index d0a6cc0d2..c03de2343 100644
--- a/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp b/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
index 84f7ed6a1..c74f20d5a 100644
--- a/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp b/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp b/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/default.fail.cpp b/test/std/numerics/numarray/template.gslice.array/default.fail.cpp
index d691cbe08..dbad4eebb 100644
--- a/test/std/numerics/numarray/template.gslice.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/default.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
index d26a7b36c..a2f001427 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
index 2f960c12d..147c6e29d 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
index bd2ad7074..fb1f3b5ee 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
index 6875c5ea7..4aa5f0245 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
index 33a00328f..9631d67b0 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
index addc43da0..d74ceaf96 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
index 37555fdfa..9ed9fcd95 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
index 24e96e821..f6c1007e8 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
index ddaf4f7ca..92987929e 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
index 4c06a29e5..e61715849 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
index 3feda53ae..6b5075e05 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
index 125935169..285e44cde 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
index 5c5591aa1..d3e987078 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.gslice.array/types.pass.cpp b/test/std/numerics/numarray/template.gslice.array/types.pass.cpp
index 005d907b4..4fcc77177 100644
--- a/test/std/numerics/numarray/template.gslice.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/default.fail.cpp b/test/std/numerics/numarray/template.indirect.array/default.fail.cpp
index 2f5e5d832..203a91726 100644
--- a/test/std/numerics/numarray/template.indirect.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/default.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
index 9c7c816ce..5b27d5e0a 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
index ad934aabc..f3f0a49a4 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
index fa966d1b5..297b9ed85 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
index 60f055276..1dcb9c0b1 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
index 11b5d83fe..1112bca9f 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
index 4c63684ec..061735a26 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
index e47735310..d64ff33f1 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
index b74ce8621..11240333c 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
index e23f14299..160bb8059 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
index 33db33f0c..fbebc1a25 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
index dd2d35f99..1d4a5bf14 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
index f2c3427b9..0a6434454 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
index de2bb4344..d49f2a0f6 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.indirect.array/types.pass.cpp b/test/std/numerics/numarray/template.indirect.array/types.pass.cpp
index fe118ea32..6cc9988aa 100644
--- a/test/std/numerics/numarray/template.indirect.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/default.fail.cpp b/test/std/numerics/numarray/template.mask.array/default.fail.cpp
index 97476c65c..5bec2dcad 100644
--- a/test/std/numerics/numarray/template.mask.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.mask.array/default.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
index 29cb787d0..d16040556 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
index 63949e244..e7e0d3740 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
index 984762943..084a0d11b 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
index 7e110b13a..e797343b6 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
index 9fe243875..dc7bbb2f1 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
index bd0ee0836..302cdcc3e 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
index 13efefc37..cfe282203 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
index 9b06879a8..2fdfe0de2 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
index 9c1f92a3e..aaf6f2d43 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
index 438d3427d..15d745e02 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
index 16e387dc6..7b09a0ec4 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
index ae3c2383d..5487ea024 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
index c37916b0b..63558d8d5 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.mask.array/types.pass.cpp b/test/std/numerics/numarray/template.mask.array/types.pass.cpp
index c984c3fea..6848c655b 100644
--- a/test/std/numerics/numarray/template.mask.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/default.fail.cpp b/test/std/numerics/numarray/template.slice.array/default.fail.cpp
index 3b522f0e1..59f5fdf0e 100644
--- a/test/std/numerics/numarray/template.slice.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.slice.array/default.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
index 60b94ab5f..40dc0be71 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
index d3857863f..7ea08cfae 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
index 8b5bf75d4..5934c2015 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
index dbcae8477..3af46538b 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
index 71785015b..508ebbbd8 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
index e08fb51a8..7b3919e49 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
index 257c03164..ffcd85424 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
index 0826708a3..b40544234 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
index 84360d8c9..fcf51bb18 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
index c39cd53e9..4c79b559b 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
index e6419fb2c..aae003cf3 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
index 294106ed7..afebc8820 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
index 4f7af4baf..ed1b219a6 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.slice.array/types.pass.cpp b/test/std/numerics/numarray/template.slice.array/types.pass.cpp
index 8c40b154f..0d1989a48 100644
--- a/test/std/numerics/numarray/template.slice.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/types.pass.cpp b/test/std/numerics/numarray/template.valarray/types.pass.cpp
index 71421e543..301192ef8 100644
--- a/test/std/numerics/numarray/template.valarray/types.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
index 2e3b83ec7..dc90dbef9 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
index 8d5630516..a4c81440e 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
index da1225ae0..24f6cc54b 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
index dff523f19..625cf17a8 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
index 6e8069cc2..3c351d0b3 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
index 7923b104b..4f9b60db6 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
index a52c9d9d6..592e306e7 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
index 19b74ba28..263c093b9 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
index 9a7517aa1..5ccfa2e08 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
index cf1d34a11..c722f8b1e 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
index 9ceae5f2d..d6f7c57d5 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
index 2d74a3337..6c37d2bc1 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
index 914e632d5..a5cccdc86 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
index 58ea7f18b..bff87ab95 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
index 2cc2cce56..e574de21f 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
index 49d7c7f5b..0dee79df7 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
index 3bbff9943..5dc7ca5ce 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
index d372d88a4..0e306cefc 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
index 4a1be1916..97e3b9b99 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
index bab99bca0..ba44c578d 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
index 5f6047f65..67ed8bc5c 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
index 0b5e88eda..730ac7f15 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
index 962648118..91ea80ed2 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
index 05fa3b94c..abbb0023c 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
index 7161d27e6..f5fc5c724 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
index 726ac9b8f..00f5e2560 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
index 02c0cc59e..00ac963b7 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
index 1740e449d..a039f9f8c 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
index 452b581e0..f9d8ba3b5 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
index 6951653b4..02c139824 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
index 6ebff7256..a97a25047 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
index 9933322de..ff4a7a254 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
index 56601dc92..7e061f50a 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
index dbca1f9c7..e525b2a4f 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
index ce385e65c..bd47c5798 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
index be4f74039..e9deea94a 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
index b8fb08e0f..010649a92 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
index f98230f47..84d51b035 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
index 221187c4e..7e539d9c2 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
index b67641414..c5667671f 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
index 336c898b5..6e43de782 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
index 919a3a5e4..7d4d07923 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
index dc7a1a100..d43810062 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
index 601a6df8d..1aa6a3e9a 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
index 697d4cd19..cc80ea8e0 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
index dac593437..37d8f3a31 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
index 9a527c250..82dd0bd38 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
index 9a617a91a..2be57bff3 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
index 0aae5b8de..3498cc59c 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
index 189f03d25..b1c530aa4 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
index b2b55fdc3..23cf807af 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
index 7bbd48c34..32e6b5561 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
index 282dcf1f6..12caa6118 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
index 1bc4fb929..d210e5120 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
index d0b743817..053e9267e 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
index 7f8191035..3eaafee7e 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
index 6bf9b430e..d4cb64cf9 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
index 10bdd82e5..77e86ac73 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
index cecf95022..6ea9e1849 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
index 5b2501f7e..8bb23c0b4 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
index f4a83427c..2827488d2 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
index 844b3d210..64e902146 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
index 8df049455..113bb12e9 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
index 724b86841..d195f1d24 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
index 360ffe5eb..4e083bd15 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
index 7de81179d..89fdd065a 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
index cb02459cd..4b76423ae 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
index 0b692aa35..babecfe99 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
index c6c339b2a..29316e4c7 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
index ddea683ce..af78964ca 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
index b5fc58a9f..e6760c230 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
index 1780eda20..1d984be79 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
index 58b78a322..948688ba3 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
index 083fdabd8..101b32d53 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
index 55801ca69..dc2ecc0f8 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
index adea116c9..c01d33a2b 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
index 3f526b8f6..328afb2a4 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
index 246a48532..e5ca45963 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
index 82ebebaa7..c65a7b2a6 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
index 68c752821..46b7fbb55 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
index 723ec62d8..97b7791de 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
index 31d50eeb8..90f9d756c 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
index 646b55ed3..5136d3fd9 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
index 5ddce6fd4..697b46db8 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
index b6c4c1150..4194c191a 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
index abc7726de..4aabb8a94 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
index 956ec055c..cccdca18c 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
index 23cbdbe92..c15b794ce 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
index cf87f0094..155ea25b5 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
index 23b078e2d..b825ad54e 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
index e550d0c7f..5e07f5d44 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
index d7d5aa497..bc22ebadd 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
index 3e83ff9ae..14574a10d 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
index 003ed3d2c..3e0951b6e 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
index 59f2999a2..75bce73a2 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
index 9be01bfcd..a6cd5e836 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
index 78dabed3a..3b43c1097 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
index 31c040bfe..1bd1fa0e8 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
index 89d627de5..5fb05f60a 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
index f4a5e18e8..6f7678fc7 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
index f0ea1e9f1..f26e94694 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
index 99b97d55c..2c795aae3 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
index bdfd191e4..03468763f 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
index a6cef8672..970f8d8d5 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
index 712e39681..ad30ae425 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
index 8ba8394fa..86e5553a8 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
index 242ce8a42..d520a21b9 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
index 1b9ea4dcc..2055f7554 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
index 5a5408537..0eb137ca0 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
index 50b074a1b..d7d6b7d8b 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
index 248037d44..34419bdec 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
index a4404d14a..4daca5332 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
index 45df48f94..add76d16c 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
index 854546447..a35038051 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
index 1f2a7da96..ef2b16509 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
index 426c0558b..60f14f2bb 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
index 3bf0fe79d..0d9a3124e 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
index cb1807bf3..478350837 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
index 9af8b1a93..ff5c7d89a 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
index 2814e2ed1..bee16abd7 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
index f2f873cc6..4cecd8cac 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
index d5ae07be3..7e81821dd 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
index 8345f950d..3ab737577 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
index f28a69a17..07e7894ae 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
index 78740a2b8..567f568a9 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
index eb5b9a307..182b8bc3a 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
index f8075d31b..fb0965bb3 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
index 741e1abba..3c19e3edf 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
index a2cfe6846..70ba211a8 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
index d3795f97f..3e616a062 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
index d0f8bdb7c..096cd5d32 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
index 22017237b..902c9f321 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
index e34f664c2..394497823 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
index 30b30caf9..2cf38b88b 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
index 6fbb4f063..fa591d0c6 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
index e577a83ad..eb40e61b3 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
index 9db12a351..6395ee550 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
index dfcd53106..10e0a22be 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp b/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
index 873c4847e..db39ab4a1 100644
--- a/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp b/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
index 0a39d009f..fb4013dee 100644
--- a/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.range/end_const.pass.cpp b/test/std/numerics/numarray/valarray.range/end_const.pass.cpp
index 4d0015343..113216ad0 100644
--- a/test/std/numerics/numarray/valarray.range/end_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/end_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp b/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
index 012434e8a..c5d54729a 100644
--- a/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp b/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp b/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
index aae97ef41..2a14a7d8e 100644
--- a/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
+++ b/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp b/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
index 19a872868..a6dc04b2d 100644
--- a/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
index f999c5045..ac0b17741 100644
--- a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
+++ b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
index 8a30a8221..967ec2ea3 100644
--- a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
index 7026b73c6..5568e0d80 100644
--- a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
+++ b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
index 4fd5e236e..78c8325e2 100644
--- a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
index 2058b8e3d..b02ce5408 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
index ca4da9841..07561175b 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
index c3b0feb34..06a187454 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp b/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
index 68a8c49b8..fec9182b1 100644
--- a/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
+++ b/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp b/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
index 31dbbd0be..d0d152db1 100644
--- a/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
+++ b/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp b/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
index eb7c8373a..312867425 100644
--- a/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
index 7a8a60835..70173d08b 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
index 909d7cbfc..106434d97 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
index 75a1bc128..138bdd6db 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
index 406b49850..8e8e75593 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
index 9354a4eb0..7bcf29d13 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
index fa1b7da48..aceb0ff63 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
index 517a62a00..83a90b984 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
index 1492c25ad..43fc1f5bf 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
index de891f3ee..b9e1128dc 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
index d2a7f52e5..763b65f99 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
index 88ca68bf0..dd7c43a41 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
index 082631dc0..81f25887e 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
index 8ab68a4e6..ef039ca79 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
index d96ca3225..a42303776 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp b/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
index cb468e019..90a74e22f 100644
--- a/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
+++ b/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp b/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
index d8f2a93e4..eadcd5a3a 100644
--- a/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
index aa055e70d..ebdaaac91 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
index 480ead11c..22b5a7239 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
index cff1b8c0a..7c2692171 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
index ff0cb29f4..dc9412ec1 100644
--- a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
index 48aeadb87..412c4b292 100644
--- a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
@@ -1,10 +1,9 @@
 
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
index 00c4aafdf..d29131bd1 100644
--- a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
index c5bcaf148..541fbb76f 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
index a79b4e98f..8f846a893 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
index f60a0f149..586e7b180 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp b/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/numerics.general/nothing_to_do.pass.cpp b/test/std/numerics/numerics.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/numerics.general/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numerics.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/nothing_to_do.pass.cpp b/test/std/numerics/rand/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
index 5238915ee..dbc038fc5 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
index 80417e5d6..78bc6b297 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
index d6b8b33ad..a0833fb4a 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
index 1e8e2fe6f..5df116384 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
index dba254f1a..4022917b9 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
index b64d4b316..c56bf4503 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
index ffdaebc17..703dd3d7c 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
index d10b7c5e8..ca675b9ff 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
index f819d6a97..33e0f73ee 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
index 4b742f06a..ebfddfc37 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
index 2634aba38..7df00d8e6 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
index 6a5ff14f7..0dff0790c 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
index 0da09a379..738b306b2 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
index 5666fdce2..fef9ab497 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
index 4484b3db4..def8387e1 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
index 6a01af4bf..179ffaf46 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
index 193f5c33e..c858600cc 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
index 60a661d39..1ecf36c43 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
index 8e8d3091a..9fa1383a8 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
index 7965f4397..a179753a8 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
index ccb6f379d..422aaf936 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
index a1b4dd7d7..fa735c09e 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
index a5893ead7..036dc1fbc 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
index 9bcf06488..0362cbfc2 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
index 9ae955478..ee47a38b9 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
index e8c24ca5f..204c89739 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
index ec83fff7f..5c1c34e72 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
index 6076f934f..10d9f4d75 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
index 652e6487a..d3518432c 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
index de26e2dc7..7c4930879 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
index e71aa1d89..4bd805262 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
index 4a347b5d5..6daa356a7 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
index 320249497..ba0350fc5 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
index a08df07b3..3d3c06db2 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
index 7b4bc5820..438c60790 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
index b442a76ad..3e98bf554 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
index d2a5292e1..fa7056ca9 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
index 6c8fdb998..5d7a49a5f 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
index a6f1eadb0..5ba0b5ed2 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
index 57ded845e..0d71f27e2 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
index 4b4b099bc..0a5d386b1 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
index ac3f1d711..8f9e52442 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.device/ctor.pass.cpp b/test/std/numerics/rand/rand.device/ctor.pass.cpp
index 5d72e474e..c9838f681 100644
--- a/test/std/numerics/rand/rand.device/ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.device/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.device/entropy.pass.cpp b/test/std/numerics/rand/rand.device/entropy.pass.cpp
index 141a84a6d..381971377 100644
--- a/test/std/numerics/rand/rand.device/entropy.pass.cpp
+++ b/test/std/numerics/rand/rand.device/entropy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.device/eval.pass.cpp b/test/std/numerics/rand/rand.device/eval.pass.cpp
index e5a2a32ee..b5b8aa11f 100644
--- a/test/std/numerics/rand/rand.device/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.device/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
index e55c1579c..bbd200d21 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
index c64f925b4..bf4291cec 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
index 5d511fcc6..1d9a22d1e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
index a143b5a68..5543f4073 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
index b77c12eed..faa683d4d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
index 0118ae0bf..a16d52475 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
index 0cdb0b77a..6d83410d8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
index 1b4eae90b..d24316d87 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
index 5f57145e1..5107e9006 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
index 8e669bbda..acb1ada86 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
index 296ad1474..626f014b8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
index a24dd0dfc..f8ea5be59 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
index 6c4eaeee4..91a8bacb7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
index c43f44721..cf1b7d391 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
index ee5dfe867..b41a8f778 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
index 5a3b90332..a8d6ba15f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
index 9869ac6fc..55af45597 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
index 4b6c4be1a..0be93b4b0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
index 82473d288..746a35fb5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
index 715494886..f66192938 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
index 5a3a22eee..f9ff59cd4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
index cfb98f298..569ec41c3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
index 738bdc80e..b6c8aeb4a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
index de5b153e0..06f16c257 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
index 5ce0cb412..78a9e6e3b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
index 88c8424b0..304a6b61a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
index 1276454b5..90eeb394c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
index 9c88faabe..946e7ed93 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
index 678a34b2f..c6ac01110 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
index 553f8ad82..24250bbce 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
index a9770efa2..9445502ed 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
index cadf84a89..2a7f92843 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
index 3c2c1faa5..0e705adcf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
index 6c745611c..4e95286f3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
index 612f5e2de..66f1d875d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
index 0e71aa019..60f811499 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
index f71b37482..99d7a6dc1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
index 00f3d04ae..ea83185e5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
index 461542896..f099589c8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
index 5cf93eb46..f682fb71c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
index 38d423bb5..aa358fe74 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
index 6e6072a4f..4addb5e15 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
index 254c347b3..a3194c4d1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
index 00797a119..2ef240620 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
index 3e3752af7..fb419b468 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
index b381bc438..00a3780ed 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
index 56b75a7f8..ab9e964f0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
index 98b84d59a..0b6033d39 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
index 4397aecfb..92f917767 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
index c78525fea..75a9b436d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
index 374f2b0b8..973491fd8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
index 33a4c6fff..bb80250a1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
index e8aee01fb..e66f9ace4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
index 367e3f987..528996f50 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
index f62c52eca..8b6d1e5a5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
index 37c003d35..68c7703b2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
index babf1d464..3b18e8068 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
index 109a47e87..51b875da9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
index 0bf34eed6..7fa43ae9a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
index 17503364e..039403eea 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
index 6467dbf57..d1f6b6258 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
index 65f4a978c..0cfe69f0e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
index da5e8af61..cb5ca473f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
index 2fe7184e6..c5c1cc106 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
index 15bec5a7d..2dfa797cc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
index dc4d35c70..d2e948771 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
index ec5af5b85..ded919569 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
index 6d713ce71..0fc228a32 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
index b0f81cdfa..d65fa544f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
index 282ca190c..0ac9230ce 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
index 05c204f5c..d785330a4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
index 149f50752..6d2b75585 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
index 3003e0db9..66d5a7ade 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
index 032191493..3d7db5423 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
index a0406b026..eb4068c4b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
index 0973b60a7..aedfbb5d3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
index 005e141b4..e4e296356 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
index ca669dc41..f578164bd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
index 318c29e76..450e19225 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
index 0e2d6b049..635d116eb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
index ca53792c6..73a7e11ae 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
index 263c1773a..bfde51747 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
index 0d52179ae..2e2ba7db8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
index f8e085283..c2a7a04dc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
index 28ef06827..0ee42ef64 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
index 8ae5137aa..3c4467068 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
index 6210321fb..12ce7de78 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
index 56b1f6f91..327d1e7d6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
index 201ec60b0..9b5b4af16 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
index 919a7b1b6..b88e6328a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
index 0c3a0aed2..cd25b1929 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
index 9496184d4..c7881c686 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
index 27401d91e..77279803e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
index afd5aa91c..7cf8c7dfb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
index 88630b0cf..f26b78a79 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
index 3261880c6..81f3359eb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
index dbc2d09df..09a33327f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
index f12a0519b..0173fb3f4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
index de16fa1e1..fde2fecf0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
index adf4f96eb..d5b337f2c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
index 4e51590bb..54d800559 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
index 85730f619..fa243f22c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
index 3ddb02b72..c73f93a32 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
index 34d865115..34476f939 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
index cb738ea85..e40f5d19f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
index 257016b3c..4ecb983b2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
index a8d4e52b8..eecfbf2fe 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
index 614da1979..d211af8bb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
index f5294bdc5..c7eb0f983 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
index 047d51335..6ef45d0d5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
index 1dd628b62..8b5acf399 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
index 83a81cf40..2762c8dbb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
index 405c906cb..ea040c9c6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
index 8025880d8..55c8ccf1b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
index 74025b701..13818e026 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
index 572df9bed..386696ace 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
index 8872a274b..c08d61e1d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
index dfdbd5d7d..27bd09fc1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
index bd4c5d1a6..a3e382c7f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
index ea44645e6..d026525e7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
index d6ce53ae1..21364a393 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
index 1ab9138eb..7adacd37b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
index 16eea408a..f4fb9bb9f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
index 8391eedd2..3a716bf7c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
index a7a1af662..9164f750f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
index b765725d1..ee96f3460 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
index 4da6451d9..20157a2ed 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
index 777f4a1ac..4e73c9d22 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
index 39d53393d..d1116cca6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
index f16567788..f88d43305 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
index 5fee0fd4c..627f57961 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
index 82e8ffc77..bcbc04c32 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
index 35596a0d7..350a32587 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
index 348ca6cfd..a553901fe 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
index 4af0f2eaf..10ee0e820 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
index 7ebfc43a3..815db8a89 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
index 6af4df777..d199cc0b9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
index b23c770f5..3597e6d47 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
index 32ecc68da..a0657ce5c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
index 2f109e3f5..cd533afd8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
index 2f4293a73..8e4cd9a6f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
index 6e53b269e..7f2b726b1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
index 09c183f51..bc67664b0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
index 1a07000d5..ae8b59b66 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
index a7b2f71ab..77c3cfbe2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
index 63f5be3c1..fa130e4c9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
index 24a45f757..508137282 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
index 11c7fbd6e..bdb5c69f6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
index b6bd3d316..ff62af280 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
index 2bf9204d3..b2cf8534d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
index 8527052c7..55f0c8180 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
index 8b5d4328c..f17395501 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
index 6d7943349..765c45187 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
index 3825704f5..9218cfa83 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
index 9ba754d37..1ec456425 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
index 2f7329b47..08195232e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
index bddf0023f..cc16ec7e3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
index a1add140c..f58fd3b5a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
index cf2093808..859dba8a4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
index 8d9b97e74..ef88be799 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
index bb01bb1c0..7b4e9ca4b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
index 771685a8c..754e2c28d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
index 80c0a1978..e2566347e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
index 032cf77e8..0f64eb7cc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
index 7dfb97fb0..88827fee4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
index 57dedea87..ba286242c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
index 73e834043..e51365813 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
index 6ae230180..d8b3783e9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
index 983a2d243..cb47b07a6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
index a702a9fc5..f1cd34de7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
index d3ca6ee28..8fb8381da 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
index aab361eaa..f64207c40 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
index a615f8efe..8f6d4f65b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
index e900c2566..25137f9c1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
index 9ce6a9162..b207d7dec 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
index c9d0e131d..bcaac8774 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
index 83634b2e3..eea4cc99b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
index 6cdd5c403..b064d111c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
index 681d335a5..2b4516811 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
index 9a25ce2d6..c9fc1aacc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
index c2a11a15b..8ce712a54 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
index 81ae8e012..df5b00fb8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
index 92205a8ab..479f221e0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
index cd9782bf4..31926e520 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
index e31a14d0d..27841184c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
index 71aaa081b..db71f9c90 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
index 465f5a70a..28f6e6d78 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
index f5bd8107e..c33383261 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
index eaedc8770..d8b4da1f3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
index 204cd7c0c..bf02b03bd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
index 60af4bc81..abca78185 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
index 1f5352192..47ca9d508 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
index 360bd5daa..df00ddd22 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
index 7d74c7fcc..9eb9881f5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
index 416d18cab..085f55639 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
index 3d7371165..9e43dff4a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
index 6c295aa1b..bc3618578 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
index 3d444e631..fe9f84be0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
index ff7cff45e..8aab78c07 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
index 303779768..48f8b46b7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
index f5068d98d..2b02acf62 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
index cac06699e..3e569438a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
index 6280df4f5..8d5e08f5c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
index ecc663c6c..42ccae9c8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
index b69a04cc1..ef1ca6aaf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
index 1855d5f73..fe300d692 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
index 0beaf4293..9fefd6058 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
index ca89e355b..b16f7f2a5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
index 1f98a5b17..199c14e5f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
index 44f587f62..cd2aac8ca 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
index 6675bab61..58ad1f2c9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
index 3fe3d49c3..3dd5e788e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
index 3b55d569f..532452c2e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
index d6ffb5f0c..af00f4b7f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
index dcf0b1659..f7ff8fdf4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
index 44dd1816c..53ad76218 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
index 671f4b1cd..707c5b4b1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
index 876ecb27f..b080f76a8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
index 5bc4bbaea..c359c08db 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
index 35de51b1c..a475a67f5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
index 48331a609..932c57a06 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
index 15d3a289b..b972c3f5e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
index 12167c54f..803daa82e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
index 0aad32c64..31bbbfca8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
index a2a288adf..6824616bd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
index 9ec51932a..29df49967 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
index a918c1479..37eba2f10 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
index 31f346ed5..447050500 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
index c96cbcd2e..d7eb86d23 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
index c0e34f0b5..3c72bee5a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
index 2fe9c2d71..d8cbeb23a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
index 51e8eb123..f9467d6a1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
index 7e2262990..ca1c4b48d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
index 65459e00f..197a9b224 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
index 5f1455525..ee487a416 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
index 8abf7ffbd..2e141ca92 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
index 0cc82cac5..d5f86cb03 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
index a24d7550b..c8ee84146 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
index 7bea12ec6..cc7a8bd9d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
index 12fcfa354..0e3d1c2e4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
index caa56eaab..27b6a9c39 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
index 3f5f36769..8d2b76df2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
index 63805591b..e8ffce1fa 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
index 2dffab3d1..853d70749 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
index 607d49b0e..da95d9c4c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
index 1c31ea34a..1982ff5de 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
index 19c05136e..841c7ddac 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
index 081e3a2d5..8dea424b4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
index cbee35845..307a0d08d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
index c3136e048..c4e1e434a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
index 86fe1f422..406b84722 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
index 05e8b112e..16165b0b7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
index 31a2c4ad6..c6090b523 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
index 68ef4dfea..22d51fc34 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
index 34c670564..ac093c5f5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
index 5db4f1da7..4faae698b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
index 4c681c18b..12a3e2354 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
index ee0b68fb8..6d086b87d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
index e13507672..6142f847d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
index 5047a93e6..fcc21fb29 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
index 73b9aedba..7ecc16f57 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
index d3a44b305..30b504a96 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
index fee46ab51..16a89bcd4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
index 2d978cda2..3be04f268 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
index 815a2c732..800d6302a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
index 3f9e29f8d..f88ba3545 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
index b94e6c19b..621eda13f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
index 102f68d47..cd7d5209f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
index b200e43c5..05acfd5e6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
index 6f82c7047..bd9b47479 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
index aee3f74f2..a6d6822b6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
index b133ac708..0b1b7b919 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
index 3c1ed6a18..89fc479f2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
index 34af69382..700eb91ba 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
index 031839317..51e43f4d2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
index 65e14eeed..eafbd1b56 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
index c12fe45db..8a18ab83e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
index bad06987b..302e171ca 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
index 55080b252..170fc16a7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
index 8d8a22424..dbfd5da94 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
index 4970c5aae..26ef68c66 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
index 924995016..4e95cc477 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
index b1d1acdab..c6356cf76 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
index ab9383238..b40c4c513 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
index ea57852b6..23decd2b8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
index b65ebb0d8..a50a5f424 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
index bd2a8c83d..b915e2cb5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
index 6d43b2234..8d00e6283 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
index 1144bfed3..69ffe3d46 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
index 7ef646707..aa7d6bfb8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
index 6ec2c2aad..aac1d00fe 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
index 086b7600f..558f8ad7f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
index bc433ec75..9334f7245 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
index af73008ff..99a474a4c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
index e5c994445..1de6fd363 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
index a3eb1f4a5..6d8e36ef3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
index e901afc39..f05cd9941 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
index 74fa23442..7c8ae7fa8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
index ecc3c8922..f86cbf56c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
index d994b0a80..463e78c85 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
index 0ccdba6b9..e9439d293 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
index 2ef9d7b6e..7cd8b1e06 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
index 14a59621f..048fb2d22 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
index b374c5ec2..0d0e6e50d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
index fdda4e8f0..b842d2433 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
index 9af776d54..e4748c15e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
index 772c36ed7..7de0052df 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
index 66618ba95..601eeecc4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
index 4d3a50358..87d78547a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
index de63a54ed..b9a22a153 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
index fd84d4671..4b3dad0af 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
index 98e3006f3..a8adb5be1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
index c037338cd..20a2cdbdc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
index 98d467c07..2b11672e2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
index 9cc554e60..c3fe7c42b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
index e039df36c..99132cdd8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
index 1a3fedb09..b87bd85bc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
index 760325979..bfc3cb774 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
index 0ba7dcb59..d150c8668 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
index 536b139dd..bb87e3113 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
index 99b0f5f4b..f96a044a4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
index 3ebaf77f7..fd42c2256 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
index 77371de45..e4db52bc9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
index 5fce58bbd..13517e1cc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
index 7dc47b4a3..2592763cf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
index 766989c58..019335ee7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
index d97898e5f..1aab615ad 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
index f455dcff9..11f2c4926 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
index 57a8ca558..56e648f50 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
index 1be2791fa..845b64a9f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
index 3dc12b692..aa46f40b0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
index 4d4a7603a..28a1b68f2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
index 055b2f58e..3534a8935 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
index 87d94940a..8d784c669 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
index 0bdf2c337..5d543cf59 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
index 27e93ab61..48e34c743 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
index 518a4f265..cff26c592 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
index 117a5ef93..61122d6f6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
index 1adffc8ca..aab37f7ba 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
index cea1e3dff..0907745d8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
index e85a2f0ce..ff96a8657 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
index a34212987..d53117395 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
index 0e04ea455..9c4d970b2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
index c09830c62..8ddf2f0b3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
index 68f2ec097..edbc060d0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
index cc3e86a42..c462f279c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
index b7a5cffbe..d1614923e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
index 1be34f615..9056a983b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
index bb5a59d4f..3d4524ca1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
index ab8fa6c98..199d9a5b2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
index 0220a5aa9..2205a3f47 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
index c0a262f8a..cd196ee15 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
index 3a0d3b2d9..d1b79a7ff 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
index 09c560971..eeb8e635c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
index 1f01e9858..33f49ede4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
index eba933c01..da9c08ae8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
index 5831f96b6..7f76fcc0a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
index 4022cfb61..84af7f98d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
index 823837ba6..a67791f3f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
index 65c01d037..5cd31e5f6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
index 9651a2f05..ebdfd0292 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
index 073c3a851..d53952ccf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
index 03abc5362..8cb0a1f43 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
index a6f4aff93..b2913b772 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
index 5fcba4346..ef0eecafd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
index 621fdc1bf..aaffa8035 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
index 8a0622063..79763903b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
index 0496d853e..58918c24f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
index 17ff93889..afea0a720 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
index 6baa6d81a..ecda47ac3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
index 3974258c5..77545c8f2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
index 07497fef5..1575b7feb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
index d64df7dac..9510b2bd5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
index 8f21ebfbd..67dc714e4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
index 62df68ca6..e9ee00564 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
index 27c0998be..5c5ad2331 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
index 1ff121def..021404ba4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
index b0e792fdd..5b75a0657 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
index 1c3a0c14a..313f4278d 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
index 641e5f479..c49d36178 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
index 311b7cd8f..97d2ef2d2 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
index db7118f4a..a489bcd18 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
index 83ad55725..67846b06d 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
index 0a36fcb71..4848a3d76 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
index 6d0057d59..ec217f306 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
index 28ebdf23d..04159baa5 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
index d261f1d93..569e76050 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
index 8156d63f0..da944061b 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
index ca2793c7f..c3aec15f6 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
index 2c2abe6e9..b649b24bb 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
index 63d7168f5..3ac6d3032 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
index a006b3324..eb0486aa7 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
index 6920aaca5..ae89e6e79 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
index 45bc493af..d695441cd 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
index 4599348f4..9f298ea49 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
index d92ffd807..2d91db790 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
index 480260d8b..58d59975d 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
index 0b17a8577..9d44192f3 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
index 28e00ec1e..8f7c699ee 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
index 26f3e1563..ce0506043 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
index 6f93e5beb..ef529ffcf 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
index 33292a041..3d05ce779 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
index 08d99b3d8..62ac9f516 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
index 60fec4462..c05831165 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
index 5944716b6..70a2b5b2c 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
index 429298dfc..3045b06c9 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
index 893f6dc34..361a0fc25 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
index 56e8759d1..13dede1aa 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
index ad33fc151..f4824cd9a 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
index 44829944b..818d66c44 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
index 834f5f69c..88d0910d2 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
index 6af195b49..cc0fa903a 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
index fa6e741da..201ec38d1 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
index 347077278..2a178388c 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
index 02f8b222d..758a5957f 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp b/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
index c6d24e633..a5b9334c6 100644
--- a/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp b/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
index 69627d79e..a06bbe966 100644
--- a/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp b/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
index 891e5cce6..9a44b4c0a 100644
--- a/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp b/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
index 63848cf95..f676f5f00 100644
--- a/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/mt19937.pass.cpp b/test/std/numerics/rand/rand.predef/mt19937.pass.cpp
index e3a79364a..281666163 100644
--- a/test/std/numerics/rand/rand.predef/mt19937.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/mt19937.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp b/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
index 67896d226..80ffb429e 100644
--- a/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
index 529586af9..c58f09dcc 100644
--- a/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
index f7311469d..30d94e696 100644
--- a/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
index f15dfd549..22c45db40 100644
--- a/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
index 4c3df3e1d..8faefbb4c 100644
--- a/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
index df2acbe9e..62e129b98 100644
--- a/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
index 6b5d75042..f9a5bc05e 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
index cf260fcc0..5e6ed7a01 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
index bf4210aa9..1002ea8a4 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
index 9712f61d6..db32abddc 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
index c0921d913..2d1656a3c 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
index 2214dca8a..3b1a79ec3 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
index 430d9b781..d169811db 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/nothing_to_do.pass.cpp b/test/std/re/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/re/nothing_to_do.pass.cpp
+++ b/test/std/re/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/nothing_to_do.pass.cpp b/test/std/re/re.alg/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/re/re.alg/nothing_to_do.pass.cpp
+++ b/test/std/re/re.alg/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/awk.pass.cpp b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
index 4fc1ea7fe..f0a62794b 100644
--- a/test/std/re/re.alg/re.alg.match/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/basic.fail.cpp b/test/std/re/re.alg/re.alg.match/basic.fail.cpp
index 04ce8fdd2..bc5e4b75d 100644
--- a/test/std/re/re.alg/re.alg.match/basic.fail.cpp
+++ b/test/std/re/re.alg/re.alg.match/basic.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/basic.pass.cpp b/test/std/re/re.alg/re.alg.match/basic.pass.cpp
index 5140ec917..d6a0b0da7 100644
--- a/test/std/re/re.alg/re.alg.match/basic.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/basic.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.alg/re.alg.match/ecma.pass.cpp b/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
index a676e9e52..c1e910c77 100644
--- a/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.alg/re.alg.match/egrep.pass.cpp b/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
index 53cff850e..8789e7d73 100644
--- a/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
index f7a6f91ef..cadbc2cc2 100644
--- a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/extended.pass.cpp b/test/std/re/re.alg/re.alg.match/extended.pass.cpp
index 8aa71f75d..b04d750a3 100644
--- a/test/std/re/re.alg/re.alg.match/extended.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/extended.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.alg/re.alg.match/grep.pass.cpp b/test/std/re/re.alg/re.alg.match/grep.pass.cpp
index efd33cb11..0c68dca69 100644
--- a/test/std/re/re.alg/re.alg.match/grep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/grep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp b/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
index 5a19edc1a..67bfd96f4 100644
--- a/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp b/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
index 95f400ce8..ec8467f4e 100644
--- a/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
index 59673ec88..b6d3e1ae3 100644
--- a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.replace/test1.pass.cpp b/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
index 13cc8f2a0..df68aae93 100644
--- a/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.replace/test2.pass.cpp b/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
index 679644f09..1cfaec679 100644
--- a/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.replace/test3.pass.cpp b/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
index c8b8c649d..ebfb20d7b 100644
--- a/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.replace/test4.pass.cpp b/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
index 251eae8f6..88816e3d7 100644
--- a/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.replace/test5.pass.cpp b/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
index 53720d6f7..bcff51edd 100644
--- a/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.replace/test6.pass.cpp b/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
index a00ac7519..923230aea 100644
--- a/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/awk.pass.cpp b/test/std/re/re.alg/re.alg.search/awk.pass.cpp
index 85f38ec63..13f9646f4 100644
--- a/test/std/re/re.alg/re.alg.search/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/awk.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.alg/re.alg.search/backup.pass.cpp b/test/std/re/re.alg/re.alg.search/backup.pass.cpp
index 8de0b650f..710cf226c 100644
--- a/test/std/re/re.alg/re.alg.search/backup.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/backup.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/basic.fail.cpp b/test/std/re/re.alg/re.alg.search/basic.fail.cpp
index 430b0a3aa..d84b1c97b 100644
--- a/test/std/re/re.alg/re.alg.search/basic.fail.cpp
+++ b/test/std/re/re.alg/re.alg.search/basic.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/basic.pass.cpp b/test/std/re/re.alg/re.alg.search/basic.pass.cpp
index 82f051a07..ee919b223 100644
--- a/test/std/re/re.alg/re.alg.search/basic.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/basic.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.alg/re.alg.search/ecma.pass.cpp b/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
index a8ae1f550..afc5a005b 100644
--- a/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.alg/re.alg.search/egrep.pass.cpp b/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
index 0bf838611..4e3295260 100644
--- a/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
index e22aa358b..381aec155 100644
--- a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/extended.pass.cpp b/test/std/re/re.alg/re.alg.search/extended.pass.cpp
index 6d95ad275..6c9cabeff 100644
--- a/test/std/re/re.alg/re.alg.search/extended.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/extended.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.alg/re.alg.search/grep.pass.cpp b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
index 0040f7bfa..8844b4e6f 100644
--- a/test/std/re/re.alg/re.alg.search/grep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
index dc0b98558..98343f554 100644
--- a/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp b/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
index 2d753ed14..b4a47f09b 100644
--- a/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp b/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
index 600425d8d..8bfcfa007 100644
--- a/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp b/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
+++ b/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.badexp/regex_error.pass.cpp b/test/std/re/re.badexp/regex_error.pass.cpp
index f1752716e..efcc44f6a 100644
--- a/test/std/re/re.badexp/regex_error.pass.cpp
+++ b/test/std/re/re.badexp/regex_error.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.const/nothing_to_do.pass.cpp b/test/std/re/re.const/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.const/nothing_to_do.pass.cpp
+++ b/test/std/re/re.const/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.const/re.err/error_type.pass.cpp b/test/std/re/re.const/re.err/error_type.pass.cpp
index 3609d41b9..4369e0170 100644
--- a/test/std/re/re.const/re.err/error_type.pass.cpp
+++ b/test/std/re/re.const/re.err/error_type.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp b/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
index c7b2a80cd..bed42547b 100644
--- a/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
index 03e8770dd..e32736630 100644
--- a/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
index 1c9b154f1..3d238c5d0 100644
--- a/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
index 41963fbb2..d3389e6b6 100644
--- a/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp b/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
index ad6111cc4..7af7e8cf4 100644
--- a/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
+++ b/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.def/nothing_to_do.pass.cpp b/test/std/re/re.def/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.def/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.general/nothing_to_do.pass.cpp b/test/std/re/re.general/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.general/nothing_to_do.pass.cpp
+++ b/test/std/re/re.general/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.grammar/excessive_brace_count.pass.cpp b/test/std/re/re.grammar/excessive_brace_count.pass.cpp
index c4dade7de..49bd06e5c 100644
--- a/test/std/re/re.grammar/excessive_brace_count.pass.cpp
+++ b/test/std/re/re.grammar/excessive_brace_count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.grammar/nothing_to_do.pass.cpp b/test/std/re/re.grammar/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/re/re.grammar/nothing_to_do.pass.cpp
+++ b/test/std/re/re.grammar/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/nothing_to_do.pass.cpp b/test/std/re/re.iter/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/re/re.iter/nothing_to_do.pass.cpp
+++ b/test/std/re/re.iter/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
index 24fb3787e..17cce2cb4 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
index c1cabff39..d944806fd 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
index cb44fb37b..ca5670bbb 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
index 16d1fa990..55b506be1 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
index 800f56434..2643cebc7 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
index f92fd8801..be4126e3e 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.regiter/types.pass.cpp b/test/std/re/re.iter/re.regiter/types.pass.cpp
index 5b79957be..07c3fa64b 100644
--- a/test/std/re/re.iter/re.regiter/types.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
index 8f90b2390..bddf58210 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
index 6d8c2f35e..eadfbdb44 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
index e71f3a692..cdbf1a591 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
index 9d538730e..87a227af0 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
index 849ec4ae5..8ecd0bab4 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
index f4601f3ed..82e067818 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
index 37fe2d976..c2213a0af 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
index d5d5f4c63..9e8fe86ed 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
index 473a706dd..5f31c5795 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
index 49d1b1b7e..f4de410b2 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
index 73ec62cfc..edde79c16 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
index 7d55bc111..c4095ebf6 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.iter/re.tokiter/types.pass.cpp b/test/std/re/re.iter/re.tokiter/types.pass.cpp
index b7777fbee..58803aa1a 100644
--- a/test/std/re/re.iter/re.tokiter/types.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
index fcaee8c3d..daaac65be 100644
--- a/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/assign.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
index 12b23a9fa..9507ea310 100644
--- a/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
index 7cd4845f3..9eba95b33 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
index 33b9cad18..30c7281da 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
index 7ec4f77a5..08fdf871d 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
index 247d27721..7ea385967 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/copy.pass.cpp b/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
index 3f212f772..c74f0a6f0 100644
--- a/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/il.pass.cpp b/test/std/re/re.regex/re.regex.assign/il.pass.cpp
index a74d9cf6e..75803e600 100644
--- a/test/std/re/re.regex/re.regex.assign/il.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/il.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp b/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
index d2af1f9b3..f2ca05a9b 100644
--- a/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.assign/string.pass.cpp b/test/std/re/re.regex/re.regex.assign/string.pass.cpp
index 65cc4a345..3cb8e8b41 100644
--- a/test/std/re/re.regex/re.regex.assign/string.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.const/constants.pass.cpp b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
index 42bc526ae..3fc28e4ec 100644
--- a/test/std/re/re.regex/re.regex.const/constants.pass.cpp
+++ b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp b/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
index 3f1eaf6b9..eabf8eab9 100644
--- a/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
index 8e886cd8d..cc1b081c7 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
index aa70258db..dc24531cb 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
index 93b21ec9e..f9e589ce7 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
index 0f30a8b20..2d07e1e8c 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/copy.pass.cpp b/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
index a266289c6..588f673bf 100644
--- a/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp b/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
index d4dc9e54f..5ece59ad2 100644
--- a/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
+++ b/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp b/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
index 31f047c71..5d7493ae6 100644
--- a/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/default.pass.cpp b/test/std/re/re.regex/re.regex.construct/default.pass.cpp
index f1d7bf769..b5c1521fc 100644
--- a/test/std/re/re.regex/re.regex.construct/default.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
index 87dcc8569..aac13147e 100644
--- a/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp b/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
index 4a93d173e..0b5d0c504 100644
--- a/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
index 347989c5d..37878347f 100644
--- a/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
index 05fba0205..877b9a4c6 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
index d37b81592..998f28db8 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
index 90a091a21..03a53b769 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
index a0ceb7051..8546c1673 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/string.pass.cpp b/test/std/re/re.regex/re.regex.construct/string.pass.cpp
index a8f2e9bf6..58f607183 100644
--- a/test/std/re/re.regex/re.regex.construct/string.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
index 5f87af102..6d504db33 100644
--- a/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp b/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
index 85900488f..a985a74e9 100644
--- a/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
+++ b/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp b/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
+++ b/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp b/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
index 7b2317265..dc5ad95cb 100644
--- a/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
+++ b/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp b/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
+++ b/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/re.regex.swap/swap.pass.cpp b/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
index a04c64d4a..b519edc25 100644
--- a/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
+++ b/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.regex/types.pass.cpp b/test/std/re/re.regex/types.pass.cpp
index 2e48b4e84..21a563890 100644
--- a/test/std/re/re.regex/types.pass.cpp
+++ b/test/std/re/re.regex/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.req/nothing_to_do.pass.cpp b/test/std/re/re.req/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/re/re.req/nothing_to_do.pass.cpp
+++ b/test/std/re/re.req/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/begin_end.pass.cpp b/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
index 85b513426..d83ef300f 100644
--- a/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp b/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
index 16ba38c61..9b8db2587 100644
--- a/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/index.pass.cpp b/test/std/re/re.results/re.results.acc/index.pass.cpp
index 8118d3c9c..e3f6215e9 100644
--- a/test/std/re/re.results/re.results.acc/index.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/length.pass.cpp b/test/std/re/re.results/re.results.acc/length.pass.cpp
index 7bf689c5b..d7d68c5e0 100644
--- a/test/std/re/re.results/re.results.acc/length.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/position.pass.cpp b/test/std/re/re.results/re.results.acc/position.pass.cpp
index b7df2c7c2..18aa79a48 100644
--- a/test/std/re/re.results/re.results.acc/position.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/position.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/prefix.pass.cpp b/test/std/re/re.results/re.results.acc/prefix.pass.cpp
index 0c8572a0d..ab389cc45 100644
--- a/test/std/re/re.results/re.results.acc/prefix.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/prefix.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/str.pass.cpp b/test/std/re/re.results/re.results.acc/str.pass.cpp
index 512bd9e69..ae5f5c7f6 100644
--- a/test/std/re/re.results/re.results.acc/str.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.acc/suffix.pass.cpp b/test/std/re/re.results/re.results.acc/suffix.pass.cpp
index a78bb67b4..7e88ab106 100644
--- a/test/std/re/re.results/re.results.acc/suffix.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/suffix.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.all/get_allocator.pass.cpp b/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
index c4fe96d4a..1e0a3ce27 100644
--- a/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
+++ b/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.const/allocator.pass.cpp b/test/std/re/re.results/re.results.const/allocator.pass.cpp
index 73347d08c..f8a5a83fe 100644
--- a/test/std/re/re.results/re.results.const/allocator.pass.cpp
+++ b/test/std/re/re.results/re.results.const/allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.const/copy.pass.cpp b/test/std/re/re.results/re.results.const/copy.pass.cpp
index ab0e388b5..f6733bdd1 100644
--- a/test/std/re/re.results/re.results.const/copy.pass.cpp
+++ b/test/std/re/re.results/re.results.const/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.const/copy_assign.pass.cpp b/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
index d390d62f0..3429b066b 100644
--- a/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
+++ b/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.const/default.pass.cpp b/test/std/re/re.results/re.results.const/default.pass.cpp
index 2fa85533a..80f4a0269 100644
--- a/test/std/re/re.results/re.results.const/default.pass.cpp
+++ b/test/std/re/re.results/re.results.const/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.const/move.pass.cpp b/test/std/re/re.results/re.results.const/move.pass.cpp
index 2c2233c76..b3d2a0f41 100644
--- a/test/std/re/re.results/re.results.const/move.pass.cpp
+++ b/test/std/re/re.results/re.results.const/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03
diff --git a/test/std/re/re.results/re.results.const/move_assign.pass.cpp b/test/std/re/re.results/re.results.const/move_assign.pass.cpp
index 2d2e81b17..55c66e9e1 100644
--- a/test/std/re/re.results/re.results.const/move_assign.pass.cpp
+++ b/test/std/re/re.results/re.results.const/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03
diff --git a/test/std/re/re.results/re.results.form/form1.pass.cpp b/test/std/re/re.results/re.results.form/form1.pass.cpp
index 55b5ade79..6046f9be0 100644
--- a/test/std/re/re.results/re.results.form/form1.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.form/form2.pass.cpp b/test/std/re/re.results/re.results.form/form2.pass.cpp
index ab7a525f4..2c9d30eb2 100644
--- a/test/std/re/re.results/re.results.form/form2.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.form/form3.pass.cpp b/test/std/re/re.results/re.results.form/form3.pass.cpp
index e4c2e3d20..ca1a30732 100644
--- a/test/std/re/re.results/re.results.form/form3.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.form/form4.pass.cpp b/test/std/re/re.results/re.results.form/form4.pass.cpp
index 2c8aa9b8f..d46d6248d 100644
--- a/test/std/re/re.results/re.results.form/form4.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.nonmember/equal.pass.cpp b/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
index 0a32f2e25..e0b53609a 100644
--- a/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
+++ b/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.size/empty.fail.cpp b/test/std/re/re.results/re.results.size/empty.fail.cpp
index 6f677f390..7a92dd88e 100644
--- a/test/std/re/re.results/re.results.size/empty.fail.cpp
+++ b/test/std/re/re.results/re.results.size/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.size/empty.pass.cpp b/test/std/re/re.results/re.results.size/empty.pass.cpp
index f03f5f752..4644a8afb 100644
--- a/test/std/re/re.results/re.results.size/empty.pass.cpp
+++ b/test/std/re/re.results/re.results.size/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.size/max_size.pass.cpp b/test/std/re/re.results/re.results.size/max_size.pass.cpp
index 1ba29b926..5293f45f7 100644
--- a/test/std/re/re.results/re.results.size/max_size.pass.cpp
+++ b/test/std/re/re.results/re.results.size/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.state/ready.pass.cpp b/test/std/re/re.results/re.results.state/ready.pass.cpp
index 1348016bb..daa1bf337 100644
--- a/test/std/re/re.results/re.results.state/ready.pass.cpp
+++ b/test/std/re/re.results/re.results.state/ready.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.swap/member_swap.pass.cpp b/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
index cd1d72a2d..9cb6ae441 100644
--- a/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
+++ b/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp b/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
index 81e6c819e..21724fc49 100644
--- a/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
+++ b/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.results/types.pass.cpp b/test/std/re/re.results/types.pass.cpp
index 0b76875fe..3f5a31d0d 100644
--- a/test/std/re/re.results/types.pass.cpp
+++ b/test/std/re/re.results/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
index 1634c5a39..050680ae7 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
index 4b74f65d7..6e7d34d78 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
index 5e2ea8fb5..672d4aa32 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.members/default.pass.cpp b/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
index 1805f7eb3..a2473552e 100644
--- a/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.members/length.pass.cpp b/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
index 20095483d..459a8fe91 100644
--- a/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp b/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
index 4c2877cd4..47659e59c 100644
--- a/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.members/str.pass.cpp b/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
index 9a8218901..c09783b80 100644
--- a/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp b/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
index 8000ab6b7..ad65ec54d 100644
--- a/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp b/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
index 9f8c9869e..63c7d815c 100644
--- a/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.submatch/types.pass.cpp b/test/std/re/re.submatch/types.pass.cpp
index e5a00ca04..8141a5302 100644
--- a/test/std/re/re.submatch/types.pass.cpp
+++ b/test/std/re/re.submatch/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/cmatch.pass.cpp b/test/std/re/re.syn/cmatch.pass.cpp
index bf467bcbc..1e7149bb7 100644
--- a/test/std/re/re.syn/cmatch.pass.cpp
+++ b/test/std/re/re.syn/cmatch.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/cregex_iterator.pass.cpp b/test/std/re/re.syn/cregex_iterator.pass.cpp
index ed5839da0..15c7ea8cf 100644
--- a/test/std/re/re.syn/cregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/cregex_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/cregex_token_iterator.pass.cpp b/test/std/re/re.syn/cregex_token_iterator.pass.cpp
index 85dca0cf2..a5b1bc583 100644
--- a/test/std/re/re.syn/cregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/cregex_token_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/csub_match.pass.cpp b/test/std/re/re.syn/csub_match.pass.cpp
index 2a87d8b6e..7c3d644fd 100644
--- a/test/std/re/re.syn/csub_match.pass.cpp
+++ b/test/std/re/re.syn/csub_match.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/regex.pass.cpp b/test/std/re/re.syn/regex.pass.cpp
index 32fcb82f1..1fe91ec34 100644
--- a/test/std/re/re.syn/regex.pass.cpp
+++ b/test/std/re/re.syn/regex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/smatch.pass.cpp b/test/std/re/re.syn/smatch.pass.cpp
index e2fc06113..bee9f9f0d 100644
--- a/test/std/re/re.syn/smatch.pass.cpp
+++ b/test/std/re/re.syn/smatch.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/sregex_iterator.pass.cpp b/test/std/re/re.syn/sregex_iterator.pass.cpp
index 146316408..a691cc799 100644
--- a/test/std/re/re.syn/sregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/sregex_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/sregex_token_iterator.pass.cpp b/test/std/re/re.syn/sregex_token_iterator.pass.cpp
index aa85680c5..6d148280d 100644
--- a/test/std/re/re.syn/sregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/sregex_token_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/ssub_match.pass.cpp b/test/std/re/re.syn/ssub_match.pass.cpp
index 181b7a307..0730d667e 100644
--- a/test/std/re/re.syn/ssub_match.pass.cpp
+++ b/test/std/re/re.syn/ssub_match.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wcmatch.pass.cpp b/test/std/re/re.syn/wcmatch.pass.cpp
index 0eb125602..4c9b7e1f2 100644
--- a/test/std/re/re.syn/wcmatch.pass.cpp
+++ b/test/std/re/re.syn/wcmatch.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wcregex_iterator.pass.cpp b/test/std/re/re.syn/wcregex_iterator.pass.cpp
index 20c0d0d54..c81aa78c1 100644
--- a/test/std/re/re.syn/wcregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/wcregex_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wcregex_token_iterator.pass.cpp b/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
index 01a7f3c74..9d407103a 100644
--- a/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wcsub_match.pass.cpp b/test/std/re/re.syn/wcsub_match.pass.cpp
index f757d3f7c..7f18b272f 100644
--- a/test/std/re/re.syn/wcsub_match.pass.cpp
+++ b/test/std/re/re.syn/wcsub_match.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wregex.pass.cpp b/test/std/re/re.syn/wregex.pass.cpp
index 23be43baa..9622b89d6 100644
--- a/test/std/re/re.syn/wregex.pass.cpp
+++ b/test/std/re/re.syn/wregex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wsmatch.pass.cpp b/test/std/re/re.syn/wsmatch.pass.cpp
index 1483808bd..98bcbdc4d 100644
--- a/test/std/re/re.syn/wsmatch.pass.cpp
+++ b/test/std/re/re.syn/wsmatch.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wsregex_iterator.pass.cpp b/test/std/re/re.syn/wsregex_iterator.pass.cpp
index 436e6d717..1f733d905 100644
--- a/test/std/re/re.syn/wsregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/wsregex_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wsregex_token_iterator.pass.cpp b/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
index 5ceb241f3..b65e41345 100644
--- a/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.syn/wssub_match.pass.cpp b/test/std/re/re.syn/wssub_match.pass.cpp
index 23b92bb2d..8f82b34d2 100644
--- a/test/std/re/re.syn/wssub_match.pass.cpp
+++ b/test/std/re/re.syn/wssub_match.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/default.pass.cpp b/test/std/re/re.traits/default.pass.cpp
index b1e23587d..b49cc8647 100644
--- a/test/std/re/re.traits/default.pass.cpp
+++ b/test/std/re/re.traits/default.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/getloc.pass.cpp b/test/std/re/re.traits/getloc.pass.cpp
index 929659d00..82e804dc6 100644
--- a/test/std/re/re.traits/getloc.pass.cpp
+++ b/test/std/re/re.traits/getloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/imbue.pass.cpp b/test/std/re/re.traits/imbue.pass.cpp
index 04b4f5f76..d2343f271 100644
--- a/test/std/re/re.traits/imbue.pass.cpp
+++ b/test/std/re/re.traits/imbue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/isctype.pass.cpp b/test/std/re/re.traits/isctype.pass.cpp
index 3d1e7470a..a2f9e2b93 100644
--- a/test/std/re/re.traits/isctype.pass.cpp
+++ b/test/std/re/re.traits/isctype.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/length.pass.cpp b/test/std/re/re.traits/length.pass.cpp
index b80f9b5b4..822f781ab 100644
--- a/test/std/re/re.traits/length.pass.cpp
+++ b/test/std/re/re.traits/length.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/lookup_classname.pass.cpp b/test/std/re/re.traits/lookup_classname.pass.cpp
index b61f772b2..74207a019 100644
--- a/test/std/re/re.traits/lookup_classname.pass.cpp
+++ b/test/std/re/re.traits/lookup_classname.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/lookup_collatename.pass.cpp b/test/std/re/re.traits/lookup_collatename.pass.cpp
index ef5c14257..3e1fd860a 100644
--- a/test/std/re/re.traits/lookup_collatename.pass.cpp
+++ b/test/std/re/re.traits/lookup_collatename.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.traits/transform.pass.cpp b/test/std/re/re.traits/transform.pass.cpp
index 7563b3952..75a6c40c7 100644
--- a/test/std/re/re.traits/transform.pass.cpp
+++ b/test/std/re/re.traits/transform.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.traits/transform_primary.pass.cpp b/test/std/re/re.traits/transform_primary.pass.cpp
index 2dd8ed247..b2dab418a 100644
--- a/test/std/re/re.traits/transform_primary.pass.cpp
+++ b/test/std/re/re.traits/transform_primary.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/re/re.traits/translate.pass.cpp b/test/std/re/re.traits/translate.pass.cpp
index 7eaf30ea7..96c77f97c 100644
--- a/test/std/re/re.traits/translate.pass.cpp
+++ b/test/std/re/re.traits/translate.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/translate_nocase.pass.cpp b/test/std/re/re.traits/translate_nocase.pass.cpp
index 601da6b86..893c0cd28 100644
--- a/test/std/re/re.traits/translate_nocase.pass.cpp
+++ b/test/std/re/re.traits/translate_nocase.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/types.pass.cpp b/test/std/re/re.traits/types.pass.cpp
index 611ef0434..0d7a2f29b 100644
--- a/test/std/re/re.traits/types.pass.cpp
+++ b/test/std/re/re.traits/types.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/re/re.traits/value.pass.cpp b/test/std/re/re.traits/value.pass.cpp
index 3a25f35df..89bf9c352 100644
--- a/test/std/re/re.traits/value.pass.cpp
+++ b/test/std/re/re.traits/value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp b/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
index e6f3d53a8..10504c501 100644
--- a/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
+++ b/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.hash/strings.pass.cpp b/test/std/strings/basic.string.hash/strings.pass.cpp
index 449ad8f11..ea97e64f2 100644
--- a/test/std/strings/basic.string.hash/strings.pass.cpp
+++ b/test/std/strings/basic.string.hash/strings.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.literals/literal.pass.cpp b/test/std/strings/basic.string.literals/literal.pass.cpp
index cbb03ef61..eed5c9420 100644
--- a/test/std/strings/basic.string.literals/literal.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.literals/literal1.fail.cpp b/test/std/strings/basic.string.literals/literal1.fail.cpp
index 721440d8a..129d28447 100644
--- a/test/std/strings/basic.string.literals/literal1.fail.cpp
+++ b/test/std/strings/basic.string.literals/literal1.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.literals/literal1.pass.cpp b/test/std/strings/basic.string.literals/literal1.pass.cpp
index f0b7b463f..5134ec79a 100644
--- a/test/std/strings/basic.string.literals/literal1.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal1.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.literals/literal2.fail.cpp b/test/std/strings/basic.string.literals/literal2.fail.cpp
index 99f92fde9..3ebbfa24c 100644
--- a/test/std/strings/basic.string.literals/literal2.fail.cpp
+++ b/test/std/strings/basic.string.literals/literal2.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.literals/literal2.pass.cpp b/test/std/strings/basic.string.literals/literal2.pass.cpp
index 3cc2936a1..ac41ce94c 100644
--- a/test/std/strings/basic.string.literals/literal2.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal2.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string.literals/literal3.pass.cpp b/test/std/strings/basic.string.literals/literal3.pass.cpp
index d6e8c8f88..c5ca6708a 100644
--- a/test/std/strings/basic.string.literals/literal3.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal3.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/allocator_mismatch.fail.cpp b/test/std/strings/basic.string/allocator_mismatch.fail.cpp
index 644137ec2..ae63acfce 100644
--- a/test/std/strings/basic.string/allocator_mismatch.fail.cpp
+++ b/test/std/strings/basic.string/allocator_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/char.bad.fail.cpp b/test/std/strings/basic.string/char.bad.fail.cpp
index 1878cd02c..d78cb6aad 100644
--- a/test/std/strings/basic.string/char.bad.fail.cpp
+++ b/test/std/strings/basic.string/char.bad.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/input_iterator.h b/test/std/strings/basic.string/input_iterator.h
index fa6bb80a1..131be9fad 100644
--- a/test/std/strings/basic.string/input_iterator.h
+++ b/test/std/strings/basic.string/input_iterator.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/at.pass.cpp b/test/std/strings/basic.string/string.access/at.pass.cpp
index 16121cbf6..6515e2727 100644
--- a/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/back.pass.cpp b/test/std/strings/basic.string/string.access/back.pass.cpp
index adf22bf0d..b4108010a 100644
--- a/test/std/strings/basic.string/string.access/back.pass.cpp
+++ b/test/std/strings/basic.string/string.access/back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/db_back.pass.cpp b/test/std/strings/basic.string/string.access/db_back.pass.cpp
index e65ef2cef..5034bfa11 100644
--- a/test/std/strings/basic.string/string.access/db_back.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/db_cback.pass.cpp b/test/std/strings/basic.string/string.access/db_cback.pass.cpp
index ee99aee10..ddffb6cd7 100644
--- a/test/std/strings/basic.string/string.access/db_cback.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cback.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/db_cfront.pass.cpp b/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
index 130496245..e171883dc 100644
--- a/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/db_cindex.pass.cpp b/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
index f96ead7bf..770ab333c 100644
--- a/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/db_front.pass.cpp b/test/std/strings/basic.string/string.access/db_front.pass.cpp
index 881a5ede3..7f2db649a 100644
--- a/test/std/strings/basic.string/string.access/db_front.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/db_index.pass.cpp b/test/std/strings/basic.string/string.access/db_index.pass.cpp
index 981a55d11..40318e398 100644
--- a/test/std/strings/basic.string/string.access/db_index.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/front.pass.cpp b/test/std/strings/basic.string/string.access/front.pass.cpp
index 5400ddb39..5eee328fe 100644
--- a/test/std/strings/basic.string/string.access/front.pass.cpp
+++ b/test/std/strings/basic.string/string.access/front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.access/index.pass.cpp b/test/std/strings/basic.string/string.access/index.pass.cpp
index f4053dff1..d529567c6 100644
--- a/test/std/strings/basic.string/string.access/index.pass.cpp
+++ b/test/std/strings/basic.string/string.access/index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/capacity.pass.cpp b/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
index 79fbd2e96..9f09dea1d 100644
--- a/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/clear.pass.cpp b/test/std/strings/basic.string/string.capacity/clear.pass.cpp
index e0254c046..4f75e0134 100644
--- a/test/std/strings/basic.string/string.capacity/clear.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/clear.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/empty.fail.cpp b/test/std/strings/basic.string/string.capacity/empty.fail.cpp
index addb02ed3..2359dea94 100644
--- a/test/std/strings/basic.string/string.capacity/empty.fail.cpp
+++ b/test/std/strings/basic.string/string.capacity/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/empty.pass.cpp b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
index a61a410a4..56d925d57 100644
--- a/test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/length.pass.cpp b/test/std/strings/basic.string/string.capacity/length.pass.cpp
index 13e966dc6..617d81a92 100644
--- a/test/std/strings/basic.string/string.capacity/length.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/max_size.pass.cpp b/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
index a8f8126f7..68017f453 100644
--- a/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp b/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
index 3dfd32aeb..414b67424 100644
--- a/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/reserve.pass.cpp b/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
index 8b9dc13db..33699a799 100644
--- a/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp b/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
index 78200d50c..ad37dc30a 100644
--- a/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp b/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
index 288eb3252..b90053414 100644
--- a/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp b/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
index 656ea1d11..ee91ac167 100644
--- a/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.capacity/size.pass.cpp b/test/std/strings/basic.string/string.capacity/size.pass.cpp
index 4657aea44..16b236eeb 100644
--- a/test/std/strings/basic.string/string.capacity/size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp b/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
index 67ac43494..4f8158ea5 100644
--- a/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/alloc.pass.cpp b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
index 9e3fb0722..a2518a184 100644
--- a/test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
index 8b498f178..44db3c140 100644
--- a/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
index f6bacb70e..e3976cffa 100644
--- a/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/copy.pass.cpp b/test/std/strings/basic.string/string.cons/copy.pass.cpp
index cc4deb992..f2cfa8a0e 100644
--- a/test/std/strings/basic.string/string.cons/copy.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
index edd5c6e32..57a17e8ab 100644
--- a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
index 34d5f306a..a3c1389da 100644
--- a/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
index a995a51ee..1ab00b60e 100644
--- a/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
index a4de566a4..5b57fe3ca 100644
--- a/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp b/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
index 3665e23a7..7eb364e62 100644
--- a/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp b/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
index 3007b9e8f..3a8914cd3 100644
--- a/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
index 20279c853..6a512f274 100644
--- a/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
index e7fefacc0..6966e6e5d 100644
--- a/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
index 9c2a3201f..f87aac5f0 100644
--- a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
index 815b5600d..dac9ee332 100644
--- a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/move.pass.cpp b/test/std/strings/basic.string/string.cons/move.pass.cpp
index 9ed244406..1c11368c7 100644
--- a/test/std/strings/basic.string/string.cons/move.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
index bb7bdcd14..e426e2dc8 100644
--- a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
index ad9ed36d3..88bc12310 100644
--- a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
index 006b5b9b4..b039e7955 100644
--- a/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
index e0e4a4ff3..374183f99 100644
--- a/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
index d9d451dc7..b68c5228a 100644
--- a/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
index 506ab9374..1216f3f18 100644
--- a/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
index 6d660fd10..96457135e 100644
--- a/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
index 2adf0049a..21ed485ef 100644
--- a/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/string_view.fail.cpp b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
index 3d3bf4178..d7a054073 100644
--- a/test/std/strings/basic.string/string.cons/string_view.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/string_view.pass.cpp b/test/std/strings/basic.string/string.cons/string_view.pass.cpp
index 78ceae70e..f50d9e519 100644
--- a/test/std/strings/basic.string/string.cons/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
index 1d400b79b..9a50f62a7 100644
--- a/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp b/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
index b2fece8da..23e6668e6 100644
--- a/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
index a1f3c4b51..ee731581f 100644
--- a/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
index 17cb7dd16..ce4e69537 100644
--- a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
index fd9684e1f..daba3bd12 100644
--- a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.cons/substr.pass.cpp b/test/std/strings/basic.string/string.cons/substr.pass.cpp
index 13a9a4b96..05c53ac23 100644
--- a/test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
index 6091e0c06..7d1c26418 100644
--- a/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
index b1f5fcd50..87b94042f 100644
--- a/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
index 4bbd4bc86..3d75e23da 100644
--- a/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/basic.string/string.iterators/begin.pass.cpp b/test/std/strings/basic.string/string.iterators/begin.pass.cpp
index ea811113d..eedc9b991 100644
--- a/test/std/strings/basic.string/string.iterators/begin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/begin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
index fb4b4bdc3..720ba53e7 100644
--- a/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/cend.pass.cpp b/test/std/strings/basic.string/string.iterators/cend.pass.cpp
index 9ee56be78..07d885aee 100644
--- a/test/std/strings/basic.string/string.iterators/cend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/cend.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
index 90988a39a..2b8837fd3 100644
--- a/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/crend.pass.cpp b/test/std/strings/basic.string/string.iterators/crend.pass.cpp
index bb383787f..c74b907fe 100644
--- a/test/std/strings/basic.string/string.iterators/crend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/crend.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
index e46368c77..074fa84bd 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
index 3ed15d7c0..9c63eeafe 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
index 85ea2201f..c01b22662 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
index 9702090e4..a5a8d917b 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
index e42ba4cf1..b4c7fb380 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
index 69a682142..6a262e0f3 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
index 5472773e6..f3b5656f7 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/end.pass.cpp b/test/std/strings/basic.string/string.iterators/end.pass.cpp
index 3ad60269b..8d287f6f7 100644
--- a/test/std/strings/basic.string/string.iterators/end.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/iterators.pass.cpp b/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
index 8bc6e4fb2..3d9076023 100644
--- a/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
index 698d613ca..8de45475f 100644
--- a/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.iterators/rend.pass.cpp b/test/std/strings/basic.string/string.iterators/rend.pass.cpp
index 93c47e6bb..1edcb27af 100644
--- a/test/std/strings/basic.string/string.iterators/rend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/rend.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp b/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
index fcd18b7f0..f2848295b 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
index d30ca4469..04483865d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
index 7ed554039..08f554b34 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
index 823905df4..dec79a67c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
index f09ec682e..2fb973ae9 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
index 38b68aa69..a2b9ad1e4 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
index 1610ab5a1..59d0199a2 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
index b3704268a..c0c625f2e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
index 588c15ab8..21ddd9bb2 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
index 2d85b15fa..301fc77b7 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
index bf51d816e..b05417122 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
index a2114cf5a..72097dae6 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
index cb83f25d7..4bf805c99 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
index b592455a3..62a173a18 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
index 70b00619a..442d8c000 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
index 6b89df98d..3d401c8a9 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
index a899e0dbe..8c69b138f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
index 788512ba3..274703a56 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
index 2ad37f311..76dd27345 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
index e56b094a3..d445ad9b7 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
index 664d2049b..81dc3329c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
index 31add9df2..1923c62b4 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
index 858d3754e..0eba9361d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
index 8424b5429..e6f2a4e60 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
index 2c900bb31..a8e31c9c6 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
index 6bd9b7e01..d570428c0 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
index c5b7cbf9d..0acc50b45 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
index cb4b40f9e..c1b168729 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
index c9cd0c2c9..ac29e3b33 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
index e9476f48f..fb8c7e63a 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
index b4505a4c1..ee7ef204a 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
index ee5991c15..67a034005 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
index a769604c6..e64e9c997 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
index 4c3a87248..2f74fec3f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
index 67ba7ec10..23b8852b4 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
index 970cbcb17..0596ce984 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
index f39ed036e..3c15f6f91 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
index 5b32af951..7f27559f0 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
index c19fd2909..3a7696935 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
index bbe385015..53e1cacf4 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
index 2a705ebf4..8e8a1f8ef 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
index f8126bcaf..fc6f33bea 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
index a7d6a6e3c..ccbd0ff66 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
index 6c68b1566..79ae58fce 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
index 4dbc8ab1f..8a79b733f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
index f5f31254e..b47d2931b 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
index ec81001df..81ecca69f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
index dbf5f5b64..b320eff37 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
index d09c9c2ef..6718242e0 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
index 5c751285c..53465bf68 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
index 75745dab6..2e8c4527c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
index 88982e098..85306d595 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
index b49b6f987..7a75f03e5 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
index 60ecd67f1..9b35da025 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
index fe2ee1fa6..79adee487 100644
--- a/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp b/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
index 6011ea158..9937863b2 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
index 79852337a..965137c1d 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
index 5dbfe9d4d..b2255d068 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
index 0c1fa8203..a87529a0e 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
index 30e7dc6c1..85f399dcd 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
index 6489ddfca..eb272c29b 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
index a2e25196d..944bd4553 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
index c8b784c24..a00eb17be 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
index 6d39d025c..527d59d68 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
index 67d18b7a9..b1e6fa73d 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
index 27e97788c..9825c1b38 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
index 65649465d..7108d819e 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
index 88c758c7a..8f3906bf1 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
index 7bf7da890..c24d80768 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
index 090707fd8..654eca290 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
index 9bc3a4d41..5196aba1a 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
index a9aa92f37..ef8b80010 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
index fbef64627..2bc38c71a 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
index 19dd8bfbd..11ad5f151 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
index f6e3ddec4..f020c2234 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
index c1d57b0bc..39ec5cc06 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
index dec8f6f5a..f4791e3b5 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
index 2cd808659..fdf89a2c9 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
index 363e6d361..dd27087b6 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
index 4b5f7c368..4109eab33 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
index 01c7c5311..3514ffc11 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
index d9f5d7106..8ad82bf01 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
index c685bab8f..af98fa153 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
index f4ab04d60..0d7e5acea 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
index 4042997f4..93b9d2a87 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
index cdcfc9d8d..06f232059 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
index 5b9671fca..27c2b35d3 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
index 07c8282a7..ff4a35b39 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
index e709aa4fb..0c3943d7d 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
index 8e4f2fab1..d91c3b1ae 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
index c14e92a00..0b05b6c35 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
index 8fef8e60a..eec351c24 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
index 80da8cd00..9b2b7ddd9 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
index acab3592e..5354e6b75 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
index f0f540a49..5fe8948dd 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
index 208f96239..1261f5185 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
index 97a9d7cc7..bdaa49a63 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
index f19a4aa0f..64d286cd8 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp b/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
index d6695b0b3..7c713e4b0 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
index 9b66cb004..9c643a172 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
index e50c61fb1..6261ad55f 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
index 150973a7f..6219d6bab 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
index 94f7890dd..ad781f23c 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
index 55af081a7..aa44e16a9 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
index 2fcecc755..f9c0244ec 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
index be730cbc1..06b5e5310 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
index 590a15188..6a231a867 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
index 53114f37c..00245e834 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
index 80d579e30..7c3bdb159 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
index 8f0d48884..3e123ad7a 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
index 945f88054..2c4994670 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
index 0c239b323..cb6fc1e97 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
index 0296e2cbe..708a04352 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
index 4ce343351..1ea41354f 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
index fb69f8b34..3cb3e7420 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
index 494a1181f..cf8548744 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
index b2a05b29f..4c435537c 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
index 8b7f7b4a5..c8b62b1f4 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
index 105c2a6db..fc79c89d1 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
index 05925afaa..ae29e4748 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
index 3212389bb..6276c4910 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
index 7dc75184f..5cc9c0bf4 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
index 2024266df..76834c2e8 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
index 57fab60e7..254e639dc 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
index 7e46ff74a..421ec966d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
index e0bbd82f6..2c5359e5e 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
index c3d6044c4..6a320788d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
index 42a076aa4..46d61a44a 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
index b6b5b8f12..c5f1a3a7d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
index fb8ca3441..f98d66eec 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
index a084348b3..c346a0196 100644
--- a/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
index 0257e1259..a6136d3f8 100644
--- a/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
index 9a380f729..176ffbb56 100644
--- a/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
index 769b51c8d..482648ab3 100644
--- a/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
index 096f47e2a..d84a41e4c 100644
--- a/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
index c53d77f34..9a30a63d1 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
index ebcb0ea38..57a4d06bd 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
index e8d0c6b73..786affd27 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
index d7908ad85..c83acbf4d 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
index 230c4556c..3657e028c 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp b/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
index f94739eb4..767dc5063 100644
--- a/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.require/contiguous.pass.cpp b/test/std/strings/basic.string/string.require/contiguous.pass.cpp
index 1cc8e96e8..fb2e3e6ce 100644
--- a/test/std/strings/basic.string/string.require/contiguous.pass.cpp
+++ b/test/std/strings/basic.string/string.require/contiguous.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
index 4be35a765..bc9fb26a5 100644
--- a/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
index 5dec2156e..ff46fc33d 100644
--- a/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
index d542d3d79..acb90a0c8 100644
--- a/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/basic.string/test_traits.h b/test/std/strings/basic.string/test_traits.h
index f635b1d75..c45f56eba 100644
--- a/test/std/strings/basic.string/test_traits.h
+++ b/test/std/strings/basic.string/test_traits.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/traits_mismatch.fail.cpp b/test/std/strings/basic.string/traits_mismatch.fail.cpp
index 1d54238ae..7e57ae1a7 100644
--- a/test/std/strings/basic.string/traits_mismatch.fail.cpp
+++ b/test/std/strings/basic.string/traits_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/basic.string/types.pass.cpp b/test/std/strings/basic.string/types.pass.cpp
index a6832a158..0d074fe05 100644
--- a/test/std/strings/basic.string/types.pass.cpp
+++ b/test/std/strings/basic.string/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/c.strings/cctype.pass.cpp b/test/std/strings/c.strings/cctype.pass.cpp
index 695c5e40d..feb5c29d2 100644
--- a/test/std/strings/c.strings/cctype.pass.cpp
+++ b/test/std/strings/c.strings/cctype.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/c.strings/cstring.pass.cpp b/test/std/strings/c.strings/cstring.pass.cpp
index 22952e0f2..c61f5c4ff 100644
--- a/test/std/strings/c.strings/cstring.pass.cpp
+++ b/test/std/strings/c.strings/cstring.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/c.strings/cuchar.pass.cpp b/test/std/strings/c.strings/cuchar.pass.cpp
index f14eda511..989ca6b04 100644
--- a/test/std/strings/c.strings/cuchar.pass.cpp
+++ b/test/std/strings/c.strings/cuchar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/strings/c.strings/cwchar.pass.cpp b/test/std/strings/c.strings/cwchar.pass.cpp
index 116da936e..c7558859e 100644
--- a/test/std/strings/c.strings/cwchar.pass.cpp
+++ b/test/std/strings/c.strings/cwchar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/c.strings/cwctype.pass.cpp b/test/std/strings/c.strings/cwctype.pass.cpp
index 14f730b15..a7d9560d7 100644
--- a/test/std/strings/c.strings/cwctype.pass.cpp
+++ b/test/std/strings/c.strings/cwctype.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp b/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
index 311064ceb..8f80a53ed 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
index a9eb6c961..74e0f9076 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
index 71ab24898..637095127 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
index 179df9e19..bd12bfd21 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
index 39fba6b1c..ad99e30b2 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
index 8a2f2964c..7895baf99 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
index bdaf431db..ca6808f86 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
index 714202e25..242d3a173 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
index d93e49987..f556c952e 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
index 4cf2b0adc..497679636 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
index 67f0216a2..c1f885939 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
index 69800969a..01568e5a4 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
index 498abfa25..fbf8f2f58 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
index aa9594cfd..eb8df3b69 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
index ff4a93af6..6439c1ea0 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
index e28f906c0..77b8687e8 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
index 4b702fa8b..c623baa24 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
index b4be1402a..2e3b18aca 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
index 4f66d2c2c..0bf5d47ee 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
index 3b6e0d609..bb0a4506a 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
index c58db4c14..f4abe84db 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
index 42546f450..9a24cf13d 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
index 852451cb8..cd31e5925 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
index 5d882bde2..2a2a35702 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
index 232767069..4ade9b6f0 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
index b2ae8040e..ddf07a022 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
index af9378073..ea6f0ab17 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
index 2a679d0cf..9256a5281 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
index 93861461b..411f5202b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
index a40296b25..ae8792c49 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
index 373931169..90388aa43 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
index 8e0ee2f6f..af69fdcfa 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
index 1730d06cc..5d1cfa842 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
index 89c22250b..d9f983b5b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
index 178486d70..ac042907a 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
index 92dd5b87b..aef7ebb70 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
index d39798c74..91b2fb0fb 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
index 6d201db62..ac1723a65 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
index 9d691aca4..c4c01ddf1 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
index f091bd980..d3fe9a451 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
index 8641525d9..0ac49d0c9 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
index b83fd0fe0..dbe1dfe8b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
index c9820424f..1c16a55b8 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
index 801c4cf7c..4ec9a9b63 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
index 3b48af14f..65624dd5e 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
index e293115fa..b14662d09 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
index d1fab485c..eae7c82ba 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
index 5ab1c9f0b..0ac815b9b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
index 74d51667d..2f091029b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
index c48e3aedd..9d13d7dd0 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
index 2b7d793c7..4d334110f 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
index 15e645e3a..6cc58eba1 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
index f35816659..9d2e62e34 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
index f200c2332..10f800127 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
index 73c703f77..4653007bf 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
index 688e55932..5ca536966 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
index 274d93f13..69e8ddac8 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
index 96159209f..0b021d283 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
index 659be36ad..98974ab86 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
index 64c27ffd7..cfb20faaf 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
index 7a317f0d6..9b9b0ea49 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
index acb505671..42df4081d 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
index 894560d69..d6272f393 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
index f6d254f4c..f90688a9a 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
index 61499b580..9b466a5f0 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
index bd00b07ad..a89a0002d 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
index 6b523dbdd..e7e8285ca 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
index 80aca0ea7..ed59397cc 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
index 35cbb2d5f..a9176c8d4 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
index 60cbc218b..f7950b782 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
index 0d80446e7..d833bc0b5 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
index ee44f313b..751903bea 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
index 9b4c04829..7654c3287 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
index 488b03e0f..a003bdc11 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
index 12598975c..c367be47e 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp b/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/char.traits/nothing_to_do.pass.cpp b/test/std/strings/char.traits/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/strings/char.traits/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.classes/typedefs.pass.cpp b/test/std/strings/string.classes/typedefs.pass.cpp
index 15d971235..14fe38877 100644
--- a/test/std/strings/string.classes/typedefs.pass.cpp
+++ b/test/std/strings/string.classes/typedefs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.conversions/stod.pass.cpp b/test/std/strings/string.conversions/stod.pass.cpp
index 8773a6184..9909497e6 100644
--- a/test/std/strings/string.conversions/stod.pass.cpp
+++ b/test/std/strings/string.conversions/stod.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.conversions/stof.pass.cpp b/test/std/strings/string.conversions/stof.pass.cpp
index 7c1936487..8e7f4b4ec 100644
--- a/test/std/strings/string.conversions/stof.pass.cpp
+++ b/test/std/strings/string.conversions/stof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/strings/string.conversions/stoi.pass.cpp b/test/std/strings/string.conversions/stoi.pass.cpp
index efc43b3aa..36998336c 100644
--- a/test/std/strings/string.conversions/stoi.pass.cpp
+++ b/test/std/strings/string.conversions/stoi.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.conversions/stol.pass.cpp b/test/std/strings/string.conversions/stol.pass.cpp
index 481543622..8e18a0088 100644
--- a/test/std/strings/string.conversions/stol.pass.cpp
+++ b/test/std/strings/string.conversions/stol.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/strings/string.conversions/stold.pass.cpp b/test/std/strings/string.conversions/stold.pass.cpp
index 9d9dc3832..4677bd7d2 100644
--- a/test/std/strings/string.conversions/stold.pass.cpp
+++ b/test/std/strings/string.conversions/stold.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.conversions/stoll.pass.cpp b/test/std/strings/string.conversions/stoll.pass.cpp
index fe4c40b78..f8a5a6b0e 100644
--- a/test/std/strings/string.conversions/stoll.pass.cpp
+++ b/test/std/strings/string.conversions/stoll.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/strings/string.conversions/stoul.pass.cpp b/test/std/strings/string.conversions/stoul.pass.cpp
index c79c94941..e60a6a071 100644
--- a/test/std/strings/string.conversions/stoul.pass.cpp
+++ b/test/std/strings/string.conversions/stoul.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/strings/string.conversions/stoull.pass.cpp b/test/std/strings/string.conversions/stoull.pass.cpp
index 2ac883ec0..32369664d 100644
--- a/test/std/strings/string.conversions/stoull.pass.cpp
+++ b/test/std/strings/string.conversions/stoull.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/strings/string.conversions/to_string.pass.cpp b/test/std/strings/string.conversions/to_string.pass.cpp
index fdc682ce1..864425134 100644
--- a/test/std/strings/string.conversions/to_string.pass.cpp
+++ b/test/std/strings/string.conversions/to_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.conversions/to_wstring.pass.cpp b/test/std/strings/string.conversions/to_wstring.pass.cpp
index 2208ec5a3..82c3f617b 100644
--- a/test/std/strings/string.conversions/to_wstring.pass.cpp
+++ b/test/std/strings/string.conversions/to_wstring.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/char.bad.fail.cpp b/test/std/strings/string.view/char.bad.fail.cpp
index cbd2b47b9..3d04cd085 100644
--- a/test/std/strings/string.view/char.bad.fail.cpp
+++ b/test/std/strings/string.view/char.bad.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.access/at.pass.cpp b/test/std/strings/string.view/string.view.access/at.pass.cpp
index 7d5cf241e..b4b2667bb 100644
--- a/test/std/strings/string.view/string.view.access/at.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/at.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.access/back.pass.cpp b/test/std/strings/string.view/string.view.access/back.pass.cpp
index 73f773726..8c8fd420d 100644
--- a/test/std/strings/string.view/string.view.access/back.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/back.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.access/data.pass.cpp b/test/std/strings/string.view/string.view.access/data.pass.cpp
index a179cfa1c..85e02ceb0 100644
--- a/test/std/strings/string.view/string.view.access/data.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/data.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.access/front.pass.cpp b/test/std/strings/string.view/string.view.access/front.pass.cpp
index c627e02c4..6e73202d6 100644
--- a/test/std/strings/string.view/string.view.access/front.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/front.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.access/index.pass.cpp b/test/std/strings/string.view/string.view.access/index.pass.cpp
index 65eb6b4f6..87598dffe 100644
--- a/test/std/strings/string.view/string.view.access/index.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp b/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
index fda67c3bf..93cc76283 100644
--- a/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
+++ b/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.capacity/empty.fail.cpp b/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
index da1a67b08..74bd41302 100644
--- a/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
+++ b/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
index 079c89191..bb6c34316 100644
--- a/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
index 4b107b01e..bb142b0b3 100644
--- a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
index 59cd7215b..d7b113c12 100644
--- a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
index a75cb3185..4f32425dc 100644
--- a/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
index 3881372ff..9cbe389cd 100644
--- a/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
index 85455e18d..81fee1f39 100644
--- a/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
index d4dc39e89..c295645a9 100644
--- a/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
index f0058c809..b07b6a7ac 100644
--- a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
index 09f5360cd..984f2c6a3 100644
--- a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
index da6e2d90a..81d0d167a 100644
--- a/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
index 092bc23b1..3cdb0215e 100644
--- a/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
index 17c0b6bfd..3ec0222f6 100644
--- a/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
index 554663f1b..f8093c86a 100644
--- a/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
index 609edd764..e7341f17d 100644
--- a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
index 9ae1927b4..a7e51f9af 100644
--- a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
index 8a9c4dbfe..1531626a8 100644
--- a/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
index 0c981e21d..8e5539a80 100644
--- a/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
index 63a3000f9..0e01e94db 100644
--- a/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/assign.pass.cpp b/test/std/strings/string.view/string.view.cons/assign.pass.cpp
index bab788921..8247c53c7 100644
--- a/test/std/strings/string.view/string.view.cons/assign.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/default.pass.cpp b/test/std/strings/string.view/string.view.cons/default.pass.cpp
index 0c94918b5..fe1fa9740 100644
--- a/test/std/strings/string.view/string.view.cons/default.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp b/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
index c98a8bd67..7430f4ad6 100644
--- a/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp b/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
index 2e4faab95..8ad0449aa 100644
--- a/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/from_string.pass.cpp b/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
index 237d1221d..5e4a2d319 100644
--- a/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
index 006bea749..343600625 100644
--- a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp b/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
index 6c9ac6436..2a0544def 100644
--- a/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp b/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
index 7dd99d9c4..3f1f562a4 100644
--- a/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
index 67a913308..8898d11af 100644
--- a/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
index 77e1343cb..aae4048ac 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
index a15ac1ef2..0020e60b8 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
index 5587a0334..52f069676 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
index a52c57766..9378c6a0f 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
index 21722ecc7..6be6ddcd9 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
index 55e71c4f5..bc3ea554b 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
index fa9917c6e..cd978436e 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
index b8bbd86a4..545f4e515 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
index 5a792974f..8d80557d4 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
index 81881dead..f7daf3fa3 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
index 314f338e7..8fd255395 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
index 89a8f9f38..06a31a1d6 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
index b4e0196a5..147e191b2 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
index d19010e07..5a1271831 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
index 7d2804bf6..984029826 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
index ed530870e..84b5a96df 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
index 9380f6cd8..2be32a46a 100644
--- a/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
index da01b75e7..0f7d295a4 100644
--- a/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
index 387e834f4..0a5cec54e 100644
--- a/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
index 6fc87b8e9..62f50ed87 100644
--- a/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
index 4d7688206..0ff2be51f 100644
--- a/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
index ce16d418e..18fd8437d 100644
--- a/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
index eded51af2..dfc4a8361 100644
--- a/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp b/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
index 70515bf48..21dcbdf30 100644
--- a/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
+++ b/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.hash/string_view.pass.cpp b/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
index 042e1dfab..7cb775403 100644
--- a/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp b/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
index 343c297d2..c721b2fcf 100644
--- a/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
+++ b/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.iterators/begin.pass.cpp b/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
index 339f1f8fd..0926f7f90 100644
--- a/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.iterators/end.pass.cpp b/test/std/strings/string.view/string.view.iterators/end.pass.cpp
index 1533b49ba..1287cc201 100644
--- a/test/std/strings/string.view/string.view.iterators/end.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/end.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp b/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
index 0ec838718..43d1906c8 100644
--- a/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.iterators/rend.pass.cpp b/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
index dfcb836f1..a4eed7d97 100644
--- a/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp b/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
index f2f6313ae..08fe79e8f 100644
--- a/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
+++ b/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp b/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
index 41f8362d3..be9ca1e1f 100644
--- a/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
+++ b/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp b/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
index 780fbad5f..9b8eedd70 100644
--- a/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
+++ b/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp b/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
index c11e144a0..f335da958 100644
--- a/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
+++ b/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
index eb6eb1e97..e9a854b34 100644
--- a/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
index 546590326..6f45222ff 100644
--- a/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
index d170949c7..452addc12 100644
--- a/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
index f1489e7df..d11f00331 100644
--- a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
index e93d6ddfe..3f6e57876 100644
--- a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
index ddff1dd0a..e65a7451f 100644
--- a/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/copy.pass.cpp b/test/std/strings/string.view/string.view.ops/copy.pass.cpp
index 98e83ef50..3ec48b08c 100644
--- a/test/std/strings/string.view/string.view.ops/copy.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.ops/substr.pass.cpp b/test/std/strings/string.view/string.view.ops/substr.pass.cpp
index 5f9a60067..4391bb513 100644
--- a/test/std/strings/string.view/string.view.ops/substr.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/substr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp b/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
index 353dd98f4..3f07051d0 100644
--- a/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
+++ b/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
index 1511f014b..c89fdb8e4 100644
--- a/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
index 544cddd84..4ef1c8e2f 100644
--- a/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
index 61ea807ba..2d115c104 100644
--- a/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp b/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
index 353dd98f4..3f07051d0 100644
--- a/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
index 042aea601..d35222bbf 100644
--- a/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
index baaa4c973..a3ffde5c5 100644
--- a/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
index 7501926af..5a5adbd84 100644
--- a/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/string.view/string_view.literals/literal.pass.cpp b/test/std/strings/string.view/string_view.literals/literal.pass.cpp
index cc2202e83..c7d0e054d 100644
--- a/test/std/strings/string.view/string_view.literals/literal.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string_view.literals/literal1.fail.cpp b/test/std/strings/string.view/string_view.literals/literal1.fail.cpp
index 6e6854f55..05e66bf1e 100644
--- a/test/std/strings/string.view/string_view.literals/literal1.fail.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal1.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string_view.literals/literal1.pass.cpp b/test/std/strings/string.view/string_view.literals/literal1.pass.cpp
index f663d022b..956d7d26a 100644
--- a/test/std/strings/string.view/string_view.literals/literal1.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal1.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string_view.literals/literal2.fail.cpp b/test/std/strings/string.view/string_view.literals/literal2.fail.cpp
index 4907a5510..672201bb9 100644
--- a/test/std/strings/string.view/string_view.literals/literal2.fail.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal2.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string_view.literals/literal2.pass.cpp b/test/std/strings/string.view/string_view.literals/literal2.pass.cpp
index 3bb6f6c0a..653738dc5 100644
--- a/test/std/strings/string.view/string_view.literals/literal2.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal2.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/string_view.literals/literal3.pass.cpp b/test/std/strings/string.view/string_view.literals/literal3.pass.cpp
index 144a1cdd1..814ec0cbd 100644
--- a/test/std/strings/string.view/string_view.literals/literal3.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal3.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/traits_mismatch.fail.cpp b/test/std/strings/string.view/traits_mismatch.fail.cpp
index 6cd15e6a6..6a32051a1 100644
--- a/test/std/strings/string.view/traits_mismatch.fail.cpp
+++ b/test/std/strings/string.view/traits_mismatch.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/string.view/types.pass.cpp b/test/std/strings/string.view/types.pass.cpp
index 2763f7fb4..d8bb0f737 100644
--- a/test/std/strings/string.view/types.pass.cpp
+++ b/test/std/strings/string.view/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/strings/strings.erasure/erase.pass.cpp b/test/std/strings/strings.erasure/erase.pass.cpp
index 657a56c73..250fe94a6 100644
--- a/test/std/strings/strings.erasure/erase.pass.cpp
+++ b/test/std/strings/strings.erasure/erase.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/strings.erasure/erase_if.pass.cpp b/test/std/strings/strings.erasure/erase_if.pass.cpp
index d7014868f..06b9cc227 100644
--- a/test/std/strings/strings.erasure/erase_if.pass.cpp
+++ b/test/std/strings/strings.erasure/erase_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/strings/strings.general/nothing_to_do.pass.cpp b/test/std/strings/strings.general/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/strings/strings.general/nothing_to_do.pass.cpp
+++ b/test/std/strings/strings.general/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/futures/futures.async/async.fail.cpp b/test/std/thread/futures/futures.async/async.fail.cpp
index e20f1a0a5..f93c3ef20 100644
--- a/test/std/thread/futures/futures.async/async.fail.cpp
+++ b/test/std/thread/futures/futures.async/async.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.async/async.pass.cpp b/test/std/thread/futures/futures.async/async.pass.cpp
index 9adebb285..1083cb47d 100644
--- a/test/std/thread/futures/futures.async/async.pass.cpp
+++ b/test/std/thread/futures/futures.async/async.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.async/async_race.38682.pass.cpp b/test/std/thread/futures/futures.async/async_race.38682.pass.cpp
index bc82ba849..6e115f004 100644
--- a/test/std/thread/futures/futures.async/async_race.38682.pass.cpp
+++ b/test/std/thread/futures/futures.async/async_race.38682.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.async/async_race.pass.cpp b/test/std/thread/futures/futures.async/async_race.pass.cpp
index 1189f3550..62e09723e 100644
--- a/test/std/thread/futures/futures.async/async_race.pass.cpp
+++ b/test/std/thread/futures/futures.async/async_race.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp b/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
index 7f28b8a23..1676d4bab 100644
--- a/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
+++ b/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp b/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
index cd0017657..cb3f81393 100644
--- a/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
+++ b/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp b/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
index 05ad1ec9c..f39de5b11 100644
--- a/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
+++ b/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.errors/future_category.pass.cpp b/test/std/thread/futures/futures.errors/future_category.pass.cpp
index 7f407a061..e9e784c28 100644
--- a/test/std/thread/futures/futures.errors/future_category.pass.cpp
+++ b/test/std/thread/futures/futures.errors/future_category.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.errors/make_error_code.pass.cpp b/test/std/thread/futures/futures.errors/make_error_code.pass.cpp
index 3c14addf3..9e39585c8 100644
--- a/test/std/thread/futures/futures.errors/make_error_code.pass.cpp
+++ b/test/std/thread/futures/futures.errors/make_error_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp b/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
index 52972aa37..f8cbbdedb 100644
--- a/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
+++ b/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.future_error/code.pass.cpp b/test/std/thread/futures/futures.future_error/code.pass.cpp
index 35d44df5b..63769f018 100644
--- a/test/std/thread/futures/futures.future_error/code.pass.cpp
+++ b/test/std/thread/futures/futures.future_error/code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.future_error/types.pass.cpp b/test/std/thread/futures/futures.future_error/types.pass.cpp
index e741dd06e..911f562e5 100644
--- a/test/std/thread/futures/futures.future_error/types.pass.cpp
+++ b/test/std/thread/futures/futures.future_error/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.future_error/what.pass.cpp b/test/std/thread/futures/futures.future_error/what.pass.cpp
index 957d530ab..bae25af1f 100644
--- a/test/std/thread/futures/futures.future_error/what.pass.cpp
+++ b/test/std/thread/futures/futures.future_error/what.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.overview/future_errc.pass.cpp b/test/std/thread/futures/futures.overview/future_errc.pass.cpp
index 06397487a..383407d13 100644
--- a/test/std/thread/futures/futures.overview/future_errc.pass.cpp
+++ b/test/std/thread/futures/futures.overview/future_errc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.overview/future_status.pass.cpp b/test/std/thread/futures/futures.overview/future_status.pass.cpp
index 2c196aaac..23c5bac06 100644
--- a/test/std/thread/futures/futures.overview/future_status.pass.cpp
+++ b/test/std/thread/futures/futures.overview/future_status.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp b/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
index 8a3987cb5..f8a0d8a64 100644
--- a/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
+++ b/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.overview/launch.pass.cpp b/test/std/thread/futures/futures.overview/launch.pass.cpp
index a26b01f67..0ed166028 100644
--- a/test/std/thread/futures/futures.overview/launch.pass.cpp
+++ b/test/std/thread/futures/futures.overview/launch.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp b/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
index c0fe2ef88..1ad295220 100644
--- a/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
index 0311cf9b6..895ccf7fd 100644
--- a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
index 779fc5bfc..00af4af49 100644
--- a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/default.pass.cpp b/test/std/thread/futures/futures.promise/default.pass.cpp
index d108b4275..f0e3a786d 100644
--- a/test/std/thread/futures/futures.promise/default.pass.cpp
+++ b/test/std/thread/futures/futures.promise/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/dtor.pass.cpp b/test/std/thread/futures/futures.promise/dtor.pass.cpp
index 49010a67b..4d3bd9cb9 100644
--- a/test/std/thread/futures/futures.promise/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/get_future.pass.cpp b/test/std/thread/futures/futures.promise/get_future.pass.cpp
index fc606c6c8..3805a96d0 100644
--- a/test/std/thread/futures/futures.promise/get_future.pass.cpp
+++ b/test/std/thread/futures/futures.promise/get_future.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/move_assign.pass.cpp b/test/std/thread/futures/futures.promise/move_assign.pass.cpp
index ad72bf78e..46860fbe8 100644
--- a/test/std/thread/futures/futures.promise/move_assign.pass.cpp
+++ b/test/std/thread/futures/futures.promise/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/move_ctor.pass.cpp b/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
index c9971b0a3..d119b188d 100644
--- a/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_exception.pass.cpp b/test/std/thread/futures/futures.promise/set_exception.pass.cpp
index 8788c6314..bb763e9ac 100644
--- a/test/std/thread/futures/futures.promise/set_exception.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_exception.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
index 1cdeadf84..c464d083b 100644
--- a/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp b/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
index 6e2a4a5d9..9b72e4803 100644
--- a/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
index e127d2c37..0fa28031d 100644
--- a/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp b/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
index e986885c0..d0f2bda43 100644
--- a/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
index 05675725b..a5574238d 100644
--- a/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
index 79137488e..476061177 100644
--- a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
index 6a0ce3632..e2b8ae9a5 100644
--- a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_value_const.pass.cpp b/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
index 9c670c1e3..942481542 100644
--- a/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/set_value_void.pass.cpp b/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
index 30c6853c9..330d5b025 100644
--- a/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/swap.pass.cpp b/test/std/thread/futures/futures.promise/swap.pass.cpp
index 21c946981..ec72f8794 100644
--- a/test/std/thread/futures/futures.promise/swap.pass.cpp
+++ b/test/std/thread/futures/futures.promise/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp b/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
index 9a1d41cc0..928ede9fb 100644
--- a/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp b/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
index abb9928e8..44c538c97 100644
--- a/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp b/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
index 2b6633138..2878c40d1 100644
--- a/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp b/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
index 1590efd7b..10b84a411 100644
--- a/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/default.pass.cpp b/test/std/thread/futures/futures.shared_future/default.pass.cpp
index 92927f5f6..2229ee58e 100644
--- a/test/std/thread/futures/futures.shared_future/default.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/dtor.pass.cpp b/test/std/thread/futures/futures.shared_future/dtor.pass.cpp
index 39a8e517d..964180b98 100644
--- a/test/std/thread/futures/futures.shared_future/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/get.pass.cpp b/test/std/thread/futures/futures.shared_future/get.pass.cpp
index 23d33138e..b7767b379 100644
--- a/test/std/thread/futures/futures.shared_future/get.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/get.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp b/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
index 3a1ef7a68..b68ee6921 100644
--- a/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp b/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
index 15323d678..c2b52dc1b 100644
--- a/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/wait.pass.cpp b/test/std/thread/futures/futures.shared_future/wait.pass.cpp
index 6ff74f6c6..11dc4ba3d 100644
--- a/test/std/thread/futures/futures.shared_future/wait.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp b/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
index 1ec086266..4fbd8ae79 100644
--- a/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
index 4e107ca9a..02b0ce716 100644
--- a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp b/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
+++ b/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
index 9449e1490..b14f2381a 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
index 3f11d670b..655a9d7f8 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
index 9d1ad61ce..fbe3b55a8 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
index 212a12084..cae4e1afd 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
index ff07db9a2..6416df4de 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
index ed147d748..30c45eaab 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
index 14ac7614b..3da276ba8 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
index 14b29715e..334ed8f98 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
index d9951dca5..e2e44473e 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
index 07eeaaa46..e910d7c4c 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
index 8f51dccd8..a4c9c7af4 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
index a597c9d83..21a567ca0 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
index 6acf8c5a6..e148ddfc9 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
index 190afdc6a..7e4dd5522 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
index eb0091c8e..22e680f2a 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
index d90d593a7..b344398fe 100644
--- a/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
index 31ed57e22..24727b5d3 100644
--- a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp b/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
index d20f0c380..63e92f021 100644
--- a/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
+++ b/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp b/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
index e1d85ac2c..0d1a5884b 100644
--- a/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
+++ b/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/default.pass.cpp b/test/std/thread/futures/futures.unique_future/default.pass.cpp
index 84cb84650..0f11aa334 100644
--- a/test/std/thread/futures/futures.unique_future/default.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/dtor.pass.cpp b/test/std/thread/futures/futures.unique_future/dtor.pass.cpp
index af908d7e7..4105d3f90 100644
--- a/test/std/thread/futures/futures.unique_future/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/get.pass.cpp b/test/std/thread/futures/futures.unique_future/get.pass.cpp
index 87a54251e..3d50d896a 100644
--- a/test/std/thread/futures/futures.unique_future/get.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/get.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp b/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
index 4a790b06c..7d2ad6218 100644
--- a/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp b/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
index 14e2eb416..0b0e4913c 100644
--- a/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/share.pass.cpp b/test/std/thread/futures/futures.unique_future/share.pass.cpp
index 9b8667e53..392a43a47 100644
--- a/test/std/thread/futures/futures.unique_future/share.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/share.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/wait.pass.cpp b/test/std/thread/futures/futures.unique_future/wait.pass.cpp
index f6de983f3..0ec23f27e 100644
--- a/test/std/thread/futures/futures.unique_future/wait.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/wait.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp b/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
index c4f358268..5b8a01aaf 100644
--- a/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp b/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
index 541c00860..79da1c0e3 100644
--- a/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/macro.pass.cpp b/test/std/thread/macro.pass.cpp
index c1b1377d6..bfae0bbee 100644
--- a/test/std/thread/macro.pass.cpp
+++ b/test/std/thread/macro.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/cv_status.pass.cpp b/test/std/thread/thread.condition/cv_status.pass.cpp
index fe5fa05ad..af8a10ada 100644
--- a/test/std/thread/thread.condition/cv_status.pass.cpp
+++ b/test/std/thread/thread.condition/cv_status.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp b/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
index 02da345cb..22fbc98e2 100644
--- a/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
+++ b/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
index e88550c5b..e308b20e8 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
index 24d6ee0e7..d0c4c653d 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
index 6f43564c3..879d3c7dc 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
index 437ed965b..85c83f92a 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
index fd80ee99c..c281a9d20 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
index e99ebee9c..f72d36e8a 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
index 236eecc91..a34207406 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
index 8aa233f66..b7088fb31 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
index 9c0af8086..a61b000bd 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
index 45e0b8124..f99436a5e 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
index d87a188e9..f954ae25e 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
index 90ffb1d0b..f719e751f 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
index 0b8d8e965..214164ea7 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
index 84902546d..6eafc6202 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
index 210060a74..05ebff068 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
index 6bdca7b01..57b3024fe 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
index 27ead9568..cb79d8a6b 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
index 16e6ff9f1..dc124cbe8 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
index f5c8926e3..741094bdd 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
index a4b4ed991..57f6f7683 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
index 47da78833..81d69861f 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
index 921ad69f1..d76cbd443 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
index 71cbc94a7..796b66e99 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
index 1994ebdfe..276597350 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
index c0fea0355..5d1c1793d 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.general/nothing_to_do.pass.cpp b/test/std/thread/thread.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.general/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
index a0071cd65..1c7de8349 100644
--- a/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
index 0f5f5591f..7856ab96f 100644
--- a/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
index 79c639eb6..9a057d011 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
index 53abb42c0..b22e0db9e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
index 296ccdaee..1852db1e5 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
index 520c9730b..52a0397de 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
index 4a2db39e8..a3ab48984 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
index 5238ed670..745633b55 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
index d49ba8d11..edaf09c5a 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
index a05472935..d88b4dedc 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
index 5075a4268..16938731b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
index 7bb467326..4f25ec237 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
index cdf3ceeb6..219c389aa 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
index 6af3c6c95..5228ccead 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
index 79f43e860..ff6c376da 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
index d6bf57947..6f1f2e9ab 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
index f7cf49c81..2d571cb51 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
index ee36e84c0..960948421 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
index c29a3fb04..6be2e774b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
index ac338064d..1204eb1f0 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
index 341f0ce7e..2b5fae21b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
index 5fbb7244e..c7d0a192b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
index 839e12dba..f633c2e8c 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
index 9401cea2e..c899cea3e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
index 694e311b7..d0ca30c93 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
index 25d78ab19..ddf3341d0 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
index 06dc11742..884dd47b0 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
index 7feb71390..e6df4f121 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
index 836a9ae50..74e0ecc23 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
index 903b53ace..6c100470e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
index 23a0c7030..22eb3ee48 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
index 0f19174d5..65e05d39f 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
index 2b5f8c1f1..d387a8351 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
index 711ab7c6f..28685954b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
index 3f6ad2b55..1064d727c 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
index 5ab3ac009..36a2c0f83 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
index f555d3de5..c5be52afe 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
index 4ecd6c041..057991046 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
index 067302127..12045f998 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
index a49bc5071..46f4f1e80 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
index 2d5feabf8..16b1bd8c5 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
index 04aa79673..2c4993702 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
index f63256373..383d3278a 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
index 20f7d249b..1c258d6a6 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
index 242dacb1e..5f4ab4e74 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
index 0939a5792..8fee76b8f 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
index ceb293701..4cd2efeba 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
index cea58c554..3c385808b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
index ebaf3e6de..37e50815d 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
index 3f7bd25a5..cfc0befca 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
index b73590441..f1a2ef6c4 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
index c8d0aad6f..60616da93 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
index 124ff551f..bb0c00ded 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
index 598d53a65..3c89d6cf8 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
index 3fc8c28f5..ea99ba9e5 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
index 89c28e6be..9dc9ec3a1 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
index bc1e3e5eb..6e6fb6b76 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
index 7004ac009..184bc71f5 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
index f53af35ff..68f944e26 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
index f8bcb6d0d..44b1265e7 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.lock/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/types.pass.cpp
index 5baaee533..8d6a1fbce 100644
--- a/test/std/thread/thread.mutex/thread.lock/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
index 7f6333af9..d2d34a289 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
index 7e1a07ac8..5e1f17dc1 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
index 48c3a73a0..aa8a34b07 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
index ba2d54d58..f5be69b3d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
index fe8f351d7..9d3d53dab 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
index 61b56216e..613eae74d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
index 0239c0475..812951b46 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
index 8c5d26675..9c63a8037 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
index abebe9063..0342b4c2c 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
index ff546d4ad..b5b256566 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
index 81995f6c8..6b589f97d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
index e4bee4bb7..0c4fb55f1 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
index 3ac901520..ac8b9b076 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
index efc4d3254..3eb434a80 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
index 72f74d551..38be785c8 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
index f22f44c6d..fff58b1ff 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
index d2d486a8b..26bf18868 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
index 0c5bfa804..c710e0510 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
index 3656ec62e..dba5e3114 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
index a4e7670e7..8fe432fc1 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
index 0e173b0a1..c3be2b616 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
index 753d65d12..0702ba01c 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
index fbe3cdcd5..4927c3654 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
index e562c99e3..d2a24fb81 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
index b5fdbdec3..7e0886de4 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
index 69d71bf48..250ff9be9 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
index ba135a957..de6c58463 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
index 559cf8f26..40cdfe844 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
index 0caea1d09..fb766e161 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
index 58006833e..902b5ec42 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
index 61ba31d86..803b330d6 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
index 33320a7e2..aae979043 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
index fe2dd825c..7b351829a 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
index b32a26645..d61f62635 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
index 46222a70c..2e050d917 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
index 6c9c442ab..adf711593 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
index ae84be838..e34b2b998 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
index 487d6a8c2..cbdd2eb63 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
index 56e1874dc..98de22ecc 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
index 91f747bc1..a0dbde84b 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
index 63c3cfee3..9d73bb57f 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
index 3c1d6ddc6..feab81495 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
index 066eb7b30..b795315b2 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
index dfd2f10b7..be5056e40 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
index 33215819f..ebba7f3d4 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
index c47142764..dd6fe09c3 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
index 450ba8361..ca428ffb4 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
index 62f1b784b..4a1655ffe 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/nothing_to_do.pass.cpp b/test/std/thread/thread.req/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
index 4d3a742dd..64a413686 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
index 7373886f6..1afaaf7bd 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
index d3478818c..e2f3d38fc 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
index e452ac98c..9a4d6e910 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
index be3fc9c5d..af2450f18 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
index 54fc0b802..c24b0413b 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
index f66474c93..4a2e6f0d4 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
index 64d5a935b..d635470db 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
index f349e4c56..7e34729b3 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
index 0efb7713e..202d61b8f 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
index 585f7ea98..444760048 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
index e8c38016b..52d4f2cf3 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
index 0037deb1d..a9778f047 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
index 9799467c4..7a2fa869d 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
index 6dd4c3ec4..cf89066a5 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
index de52b1d00..69ea217b5 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
index 126965fe3..d07f26b16 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
index 4f1491dec..325c0bfeb 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
index 3dd7c6a60..8debe7770 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
index f9f38c85f..99cdec913 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
index f0c3ef74c..c21de04ea 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
index b97839c32..3db473ab1 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
index 49d4618e8..66c810b1b 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
index 4d1ffad45..3500f2c16 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
index 3b4b7823a..864518dd8 100644
--- a/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
index 3406fff70..59791c84c 100644
--- a/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
index 0a5a3e419..5fbaf9d87 100644
--- a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
index daf5b0cf7..5c1caa0cb 100644
--- a/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
index f18ed6e2b..6ea9a8ec8 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
index 8fbbcebe1..c14606034 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
index 8b585e5f6..99f0e38fc 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
index 86f16891a..38878e234 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
index b335935e3..ac27f8b54 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
index c5244a0d1..7b093826a 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
index dd8cf4273..057541dd0 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
index 622147c9c..ffc59b800 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
index f5ce83aa4..afe3e40d9 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
index dc629edec..6e02326fa 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
index 82d63ecad..85fdd38f0 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
index dfb187b6c..30fea45b0 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
index 9689fb014..c6e13bc18 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
index 92df0f6f2..243b9e997 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
index 2b7fe3f64..acbe241e7 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
index 71421464d..6a65d2ac6 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
index 7924140cf..e5c17edaf 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
index 96850d783..02c7afe4a 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
index 9b892abd8..ad0f2e295 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
index 8b88dcc96..51a9f8117 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
index 238d46017..ccea2b2c0 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
index 8ee048bb9..ef4220757 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
index 81c366e06..49f242ddf 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
index f4c106014..056189044 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
index 44e8709a8..a549366c9 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
index 4c6aabe21..6f3605224 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
index f6f092ba5..5c207c930 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
index 6b7273e26..5b70dd8fb 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
index 2cf548550..0f3813e1a 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
index 4f7a3af12..22987adef 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
index 68f5a7ea2..0342f614c 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/allocator.adaptor/types.pass.cpp b/test/std/utilities/allocator.adaptor/types.pass.cpp
index fcc99b191..00a007f06 100644
--- a/test/std/utilities/allocator.adaptor/types.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
index c148a39de..0a8c3f781 100644
--- a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.assign/move.pass.cpp b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
index 19289cc39..4baadb2bb 100644
--- a/test/std/utilities/any/any.class/any.assign/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.assign/value.pass.cpp b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
index d2e226604..7ccec4b3f 100644
--- a/test/std/utilities/any/any.class/any.assign/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
index 79cac4236..6c4e9576d 100644
--- a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.cons/default.pass.cpp b/test/std/utilities/any/any.class/any.cons/default.pass.cpp
index ed7a948e0..12692a171 100644
--- a/test/std/utilities/any/any.class/any.cons/default.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
index 589b3c46d..f696ac5a2 100644
--- a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.cons/move.pass.cpp b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
index 1310b6b12..265972a01 100644
--- a/test/std/utilities/any/any.class/any.cons/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.cons/value.pass.cpp b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
index 83c78923d..c80a407ff 100644
--- a/test/std/utilities/any/any.class/any.cons/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
index fdd3c8334..3ac003dd0 100644
--- a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
index 888e3a870..352b25b80 100644
--- a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
index 9b5ab5f03..f1ff60d47 100644
--- a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp b/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
index 072ac0677..9b747dca6 100644
--- a/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/any.observers/type.pass.cpp b/test/std/utilities/any/any.class/any.observers/type.pass.cpp
index 984c4137d..8d3b40814 100644
--- a/test/std/utilities/any/any.class/any.observers/type.pass.cpp
+++ b/test/std/utilities/any/any.class/any.observers/type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.class/not_literal_type.pass.cpp b/test/std/utilities/any/any.class/not_literal_type.pass.cpp
index 91ef5c970..b757f7b0b 100644
--- a/test/std/utilities/any/any.class/not_literal_type.pass.cpp
+++ b/test/std/utilities/any/any.class/not_literal_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
index cc118b348..8de9164c3 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
index 85ee8fef3..810c482df 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
index 0e3b6a43f..cd69a3d85 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
index cb9244990..c0c6e03fd 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
index e88deafce..c90df2ebd 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
index 204c5c0d6..194535824 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
index dad2973fb..e185f239f 100644
--- a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/any/any.nonmembers/swap.pass.cpp b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
index a2a40d138..3e5a91d0d 100644
--- a/test/std/utilities/any/any.nonmembers/swap.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp b/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
index d21b638d0..35ddfa32e 100644
--- a/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
+++ b/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp b/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
index 7b08f3047..9f05250d3 100644
--- a/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
+++ b/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp b/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
index e3d702a3a..36c7d3cca 100644
--- a/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
+++ b/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp b/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
index 63891b1ee..18ddf203b 100644
--- a/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
+++ b/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
index 7419b70e0..c191b191b 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
index 25df69d60..54ab577ea 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
index 6f39792e9..f426c57cf 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
index 2b3548269..5ef4791b5 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
index 198894023..d7346c769 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
index b56d3ef2b..6bca266e0 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
index fce826f42..ca57c223a 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
index 943e16217..4c025d141 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
index a543fffed..fc089e165 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
index a4d502bb8..ccc6c27e7 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
index a9a38b83c..b386b99a9 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
index 815096f6b..8d6bc70e7 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
index dbbd184c7..92f65af2c 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
index a1137ee38..b7facb38a 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
index 73f26e4b5..cc982d1b8 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
index ac43dd769..c4d82948e 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
index 5d833e288..cf065e4e3 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
index 12a78dbc7..da7880fb2 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
index 1d7c649df..ecaa45bba 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
index 59709d0ed..8e4ec60ef 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
index 12d968f42..664e3f25d 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
index d5788986d..e18139bc6 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
index 90dd9bc09..19bd1a731 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
index a5cbd17a0..757417a2c 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
index bcd353eba..c360a51b4 100644
--- a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp b/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
index abb80d06d..7632dc580 100644
--- a/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp b/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
index d4d99756f..7ec8f6632 100644
--- a/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/greater.pass.cpp b/test/std/utilities/function.objects/comparisons/greater.pass.cpp
index 50bdcceee..12111ef28 100644
--- a/test/std/utilities/function.objects/comparisons/greater.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/greater.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp b/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
index 0aacb81e9..1ac67eadc 100644
--- a/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/less.pass.cpp b/test/std/utilities/function.objects/comparisons/less.pass.cpp
index 191d58d6e..abfe09ad5 100644
--- a/test/std/utilities/function.objects/comparisons/less.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/less.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp b/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
index a6aca5d19..2e7330424 100644
--- a/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp b/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
index 777c25d52..fd3291570 100644
--- a/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
index ebae262b2..f3896770e 100644
--- a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
index d1ae6b780..b0a41447e 100644
--- a/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
+++ b/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
index 9c3f24262..f7f63a0bd 100644
--- a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
+++ b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp b/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
index 5e748c93b..483f7a327 100644
--- a/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
index dff211c60..75211ba21 100644
--- a/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
index 465e001c3..a04e49efa 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
index be22443e9..9ea6531a2 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
index 329ac16a8..9258c0a03 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
index 743ded994..c22baecd9 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
index f33b41577..c3adbf7ff 100644
--- a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
+++ b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
index d61c3773e..2bb9cb583 100644
--- a/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
index 934631903..76ba44fc9 100644
--- a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
index 40a9d480b..0d178b0dc 100644
--- a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
index c328b4a4e..3293a3215 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
index 2555cedb2..d0ce11b08 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
index f7b8e4983..59178deb6 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
index 17121d280..7f3e837a7 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
index ec65a4b9b..04adb178b 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
index dfa587dcc..dca691175 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
index 083065ca8..6a5c215a7 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
index 865dd89ce..27c3d0c82 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
index e498cfd96..098b8ac11 100644
--- a/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
index 025565f8e..4b0f016d7 100644
--- a/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
index 9a59227ab..02fe32ece 100644
--- a/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
index 357a3b48e..2ec1d53c5 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
index f5ab94875..6b6ee8a64 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
index e156fa966..50fb4f19d 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
index 7d3a5dec4..8c50c284b 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
index 1a9206e0e..b6dbcab53 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
index 829763f79..1b55baa02 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
index fd296a736..c32baebb5 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
index e927ad42c..abff663cb 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
index 75e2ecac3..159848666 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
index 3affd984a..89b787623 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
index f455f0311..acbeb9f9c 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
index adc785635..b048109e5 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
index b23153465..bddc92787 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
index 8a2a12e0f..4d49434f3 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
index 2e4633b11..b6703c0b7 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
index 8b0e83128..39050e6f1 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
index cc4ecce75..32d19ebf7 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
index 943e17087..6378a6cd9 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
index cb9fb9afa..558b7814c 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
index 3e5435da1..8f379e303 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
index 1c2be02c6..df2a43aba 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
index e9b399a2e..9f03ee7a1 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
index 83d61b6b2..06ea4e058 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
index 0813c48f3..026cfc2d4 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
index f0d6402d1..b685d53bf 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
index 9b2482fb9..7a8d3e380 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
index eeb181928..c4006a7c9 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
index 61eda7244..5f91e5c87 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
index cc4315c14..7775cad67 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
index cb45b30a9..5a6f503a2 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
index 214c3f7c5..a75aee330 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
index 5bca09687..c68a1ca82 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
index 7a4678ad1..7b59b56d0 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
index 7605e3bf6..52d07a45a 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/function_types.h b/test/std/utilities/function.objects/func.wrap/func.wrap.func/function_types.h
index f1526544b..470a3a0db 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/function_types.h
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/function_types.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
index e48b8f986..496dee8ae 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
index ac94fa536..1b0a1c63f 100644
--- a/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
index 4f783dd0f..2c0c9f3bc 100644
--- a/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
index 3c450a05d..497a9d981 100644
--- a/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
index d64c02f97..3aa24c443 100644
--- a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
index c8247a195..ca8b76711 100644
--- a/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/binary_negate.pass.cpp b/test/std/utilities/function.objects/negators/binary_negate.pass.cpp
index 53ff5b47a..1e7edcb32 100644
--- a/test/std/utilities/function.objects/negators/binary_negate.pass.cpp
+++ b/test/std/utilities/function.objects/negators/binary_negate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
index 584d3ab06..9fbe6db66 100644
--- a/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/not1.pass.cpp b/test/std/utilities/function.objects/negators/not1.pass.cpp
index f6ac7a49d..33268222b 100644
--- a/test/std/utilities/function.objects/negators/not1.pass.cpp
+++ b/test/std/utilities/function.objects/negators/not1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
index 92e3be580..032ce3429 100644
--- a/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/not2.pass.cpp b/test/std/utilities/function.objects/negators/not2.pass.cpp
index 7541753d5..208d33b4a 100644
--- a/test/std/utilities/function.objects/negators/not2.pass.cpp
+++ b/test/std/utilities/function.objects/negators/not2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
index b38a7d2f1..99cdf136d 100644
--- a/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/negators/unary_negate.pass.cpp b/test/std/utilities/function.objects/negators/unary_negate.pass.cpp
index e2498a3b5..ec00c3e32 100644
--- a/test/std/utilities/function.objects/negators/unary_negate.pass.cpp
+++ b/test/std/utilities/function.objects/negators/unary_negate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
index fede2538a..5e67db520 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
index ba3c71e48..16ce96112 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
index d9f05b4e5..64726b53e 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
index a2316063c..f7a6670b4 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
index d0dabd264..2cbb1a010 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
index f2ffd44e2..b16a4b476 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
index 758752644..3023f8da2 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
index 0aad4986a..9e283d1bf 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
index 39aa4843a..a8af5aa4c 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
index 4033e676f..fee5009a7 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
index 551562721..6302c51b8 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
index a9edf00ee..425bc6df0 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
index 61357a7fa..37d7cfca9 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
index 8d700508c..735bfd890 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/type.pass.cpp b/test/std/utilities/function.objects/refwrap/type.pass.cpp
index 68e406798..ef46e15d0 100644
--- a/test/std/utilities/function.objects/refwrap/type.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
index 27d498ec8..14a06a9c3 100644
--- a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp b/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
index a63dc5b15..9aaa28279 100644
--- a/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp b/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
index 441ddf4bd..f6d48a51e 100644
--- a/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
index 7ce4c846e..50cda1169 100644
--- a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp b/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
index 775247fc8..90ab8e1bb 100644
--- a/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/unord.hash/enum.fail.cpp b/test/std/utilities/function.objects/unord.hash/enum.fail.cpp
index 9e44bfb77..b824b51ea 100644
--- a/test/std/utilities/function.objects/unord.hash/enum.fail.cpp
+++ b/test/std/utilities/function.objects/unord.hash/enum.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
index a7ddd9a49..96c667feb 100644
--- a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/unord.hash/floating.pass.cpp b/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
index e67aa016c..1ab164341 100644
--- a/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
index ce87f5918..761c76dc1 100644
--- a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
index 7b427b9ac..6efcebc4e 100644
--- a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
index f1c56aed7..cbf2c736e 100644
--- a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
index 653fbc43d..8da459ff8 100644
--- a/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp b/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
index ed899e7ca..44ffb0178 100644
--- a/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
+++ b/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
index 841a23433..653d2988a 100644
--- a/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp b/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
index 192626935..2f2a6608b 100644
--- a/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
+++ b/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
index 9bfc5f3d9..3c522c73b 100644
--- a/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.fail.cpp b/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.fail.cpp
index c3efe72fe..3979b5ddc 100644
--- a/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.fail.cpp
+++ b/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.pass.cpp b/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.pass.cpp
index c75d20b11..e6b5a58c9 100644
--- a/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.pass.cpp
+++ b/test/std/utilities/intseq/intseq.make/make_integer_seq_fallback.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/intseq/nothing_to_do.pass.cpp b/test/std/utilities/intseq/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/intseq/nothing_to_do.pass.cpp
+++ b/test/std/utilities/intseq/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp b/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
index 636998aa0..b095dbfaf 100644
--- a/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
+++ b/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
index 71201f0ef..60f267fa5 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
index 292d68de9..a892be03d 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
index 90a9154e1..9d4631740 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
index e4aceffdd..252d99a7a 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
index ecb67adb5..94f10b64d 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
index 1060b7343..677c647a2 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
index 7a2d76c6d..a51ec6e95 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
index 8355db182..9594531da 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
index 10fbfe141..f153d95b4 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
index 8365d2261..3acedde65 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
index c72890947..b0ee16350 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
index 7f7b155c3..fae618493 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
index ff1ae2c05..60f3d257a 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
index 0112ab371..c8451b2a9 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
index 64de15c2c..7c58ac881 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
index a62336fa6..7a6bcd460 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
index 8097a66fc..eaadeb170 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
index 00ed50727..42b29a39c 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
index 2c3623793..687d892f0 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
index fe35ae487..d5977f0a2 100644
--- a/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp b/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
index af4f5bc3f..475ab04b8 100644
--- a/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.traits/value_type.pass.cpp b/test/std/utilities/memory/allocator.traits/value_type.pass.cpp
index d0c3d2c09..dec3a41e3 100644
--- a/test/std/utilities/memory/allocator.traits/value_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/value_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp b/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp b/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
index 2831399c3..5b7f710ea 100644
--- a/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
+++ b/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp b/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp b/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
index a71806330..a8d90b1ce 100644
--- a/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
index 0afab685f..7aa2dbfeb 100644
--- a/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
index 8ce49b90d..b38daf8e9 100644
--- a/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
index 04534f24d..bb1bb4f11 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
index 490309edd..df4124f51 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
index b53175376..14e5a8a3c 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
index 34cbb8dc5..09a9bd912 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
index 9ba987440..322881b15 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
index 10109383b..50076ce02 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
index e1612ae05..375b96f83 100644
--- a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
index 7f25e5776..9cd581564 100644
--- a/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
index cc1dbebae..1f13c8be6 100644
--- a/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp b/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
index 64a5c73af..0fd45fd91 100644
--- a/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
+++ b/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp b/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
index 483c32561..867bd46cd 100644
--- a/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/element_type.pass.cpp b/test/std/utilities/memory/pointer.traits/element_type.pass.cpp
index 44694fcb0..42db90ff6 100644
--- a/test/std/utilities/memory/pointer.traits/element_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/element_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/pointer.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.pass.cpp
index 66e90cfcb..4a74b5d58 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
index 85b15ea5b..0b412dac4 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
index 27b2d08b0..7e0823539 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
index 48399d535..8184d2d00 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
index 74c124901..407f4bcfb 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
index 756f89429..968d3ee1e 100644
--- a/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/pointer.traits/rebind.pass.cpp b/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
index 4caf4f650..823d4f11f 100644
--- a/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/ptr.align/align.pass.cpp b/test/std/utilities/memory/ptr.align/align.pass.cpp
index d77d13c90..c7a181eb7 100644
--- a/test/std/utilities/memory/ptr.align/align.pass.cpp
+++ b/test/std/utilities/memory/ptr.align/align.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp b/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
index e07bec4d0..956e6b118 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
index 3ff32df11..c12bf41e8 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
index 41f06c519..c042dd5c3 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
index 2ad9d04e5..f812bb85a 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
index 4e67b1ece..28450faa1 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
index d1eaca558..90836b233 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
index 05e55e3d9..bd9ef7b40 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
index e5b9eca43..d2f6e094a 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
index 8479ce123..50ce12248 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
index 319df2296..4d89f9cac 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
index 2f387a4ce..b81d561e0 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
index af20cd220..c3f46bebe 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
index 862e5be8e..5c177663e 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
index 57438e9cb..f7790fc45 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
index d914129f2..a0717e61b 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
index 4083bc367..755384074 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
index eb66ed4ad..531158ba1 100644
--- a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
+++ b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
index 4d9d698f7..90bb956fc 100644
--- a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
+++ b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp b/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
index 52aca8192..fd818577b 100644
--- a/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
+++ b/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp b/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
index c1575bda2..22efde4af 100644
--- a/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
+++ b/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
index 54c85e943..c9d1c8b46 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
index 1166a01e8..e350a0385 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp b/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
index bbf4be20f..5c99a9721 100644
--- a/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
+++ b/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp b/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
index 3f0bcead9..4a71817d4 100644
--- a/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
+++ b/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp b/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
index df77be964..4fc2e010f 100644
--- a/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
+++ b/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp b/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
index 8bd8993e5..0f7c44fd8 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
index e9237c534..bd7f644c3 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
index 5fba1fc04..8db542c07 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
index 78b04d861..4f942f6c2 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
index 4b56a8fb6..45c82c4ba 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
index 065a7e90a..d1589aadd 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
index 2351e9741..fb09a19fd 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
index e36c8a5a9..2a9b6ce12 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
index f1fe28cc1..cf6ad5b00 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
index 45cbc5099..f177420fe 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
index f72a0bb24..3b267f99d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
index b51c6cf08..b36580ef2 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
index 9f3617a2c..40f6b49d6 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
index 5ae26809f..3c6de40f1 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
index ecba90b71..dd4001a82 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
index f44c05eb7..4a96f8181 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
index 05a199cce..babf1c6ee 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
index 10d53c126..69ad9513b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
index 5d27a8865..6d2000c13 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
index abd3d378e..23b587d0b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
index 20275de60..a3ba5877f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
index 4a85633a8..8c63b14b2 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
index 30e0fce21..b7fc447b0 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
index 7d771d03c..53955aaa2 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
index 4f88a5c43..c27f9503b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
index 98fa13801..ec72834d5 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
index f40cbc3d0..6936744c1 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
index c4cd1693f..1257ea65f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
index 5a90a9a32..15e13688b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
index 3ad3232a9..6558e230d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
index 9af5d7ea8..c70e537a9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
index 3a9b3a9ca..a46b31aa5 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
index bf2a30401..9644e4f0f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
index aabc66a03..bc1d3584e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
index 55e52f49c..1948c6860 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
index e82f0fdcc..075cadf43 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
index c9cffa1fe..67f0ffd2a 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
index c813f6f6f..120171456 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
index 96a1779fe..79a0bc84a 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
index 47d24c349..ad020f89f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
index 13c2d435b..6af99aaf5 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
index 182d5f4a4..95da6f691 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
index e1dcdfc81..44a5be471 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
index 8b5ffdc14..3b7279087 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
index ea0720404..8d3af186e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
index fb5262f3b..06a285cd2 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
index 257d3ce19..d9eef4a23 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
index 17289197d..d235a50b9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
index 830aa5bbc..117a74aaa 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
index a430b5d79..354a23e70 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
index 527bbce14..0783b6e7f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
index 88e691952..2535519b9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
index 7f304054b..fd5ebdcca 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
index 0eeeed4e8..8ba4a69c3 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
index 59cd3d248..c50b68f70 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
index b627ac1cc..cf3aac86a 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
index 7bffc0699..3943b5892 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
index 85a64d0f1..3e91fa3de 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
index c33133d79..70a2024cc 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
index 58262eb43..d4db96826 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
index 6d28a5043..a47e67f04 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
index 002816875..5f7d6582b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
index 378cd0514..4b2a495a8 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
index 1b79d4970..4c6790f86 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
index 9f6f1bc75..c6ae19911 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
index 560293bbe..e857aa6a8 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
index 50ff692f9..14a2fe992 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
index 45748d7db..2263eb810 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
index b7ea8d4dc..c65755d8e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
index 6b32079c7..1362537e0 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
index e5713f375..739165c3c 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
index 5a03d926f..f763dc463 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
index 28358db6a..b29623f29 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
index d70adb940..8aaeab0c9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
index 90f958e26..351b66323 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
index 51a8fa5ae..e155e4faa 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
index fa496d4bd..7c3bcb6c6 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
index 4001efb73..38b1dee09 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
index d61ac51af..f2fccb558 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
index 956884b5c..883de740c 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
index ccffc2a66..c916a8907 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
index 23df0d8e6..d8483d9b6 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
index a38bf67c2..b323da7d5 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
index cb895cd2b..a85120ae0 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.help/bool_constant.pass.cpp b/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
index dcacf379b..b9037f527 100644
--- a/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
+++ b/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.help/integral_constant.pass.cpp b/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
index bf8aa0453..89d648750 100644
--- a/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
+++ b/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.logical/conjunction.pass.cpp b/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
index d8dd386e9..0b9a03621 100644
--- a/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.logical/disjunction.pass.cpp b/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
index f5ba178d6..00a1b306d 100644
--- a/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.logical/negation.pass.cpp b/test/std/utilities/meta/meta.logical/negation.pass.cpp
index 7b4eb27a7..d399a5c84 100644
--- a/test/std/utilities/meta/meta.logical/negation.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/negation.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp b/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
index 4b17a9f96..c2b84b354 100644
--- a/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp b/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
index 20c9eca8e..faffaf6b3 100644
--- a/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.rel/is_convertible_fallback.pass.cpp b/test/std/utilities/meta/meta.rel/is_convertible_fallback.pass.cpp
index 5a607f3b1..057d3b658 100644
--- a/test/std/utilities/meta/meta.rel/is_convertible_fallback.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_convertible_fallback.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
index 1b2a9286f..a2dc09072 100644
--- a/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
index 3be3d46f2..e4ce36b50 100644
--- a/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.rel/is_same.pass.cpp b/test/std/utilities/meta/meta.rel/is_same.pass.cpp
index 9db367391..634580550 100644
--- a/test/std/utilities/meta/meta.rel/is_same.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_same.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
index f7902a2be..62699fed4 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
index aa175d9eb..1c0f98848 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
index ef1aa8acb..c7fb61232 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
index c0c2483e4..0662c9dd4 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
index f29fb06cd..476a780a4 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
index 426d22d29..d53d6f805 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
index a6ce05756..569b9642d 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
index 90b8d4bcb..358d2fa8b 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
index 012741ff6..08c0b8bb1 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
index efee5064c..2564f1120 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
index 3e58b51a6..800a0074c 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
index dbbbe159f..70d2ddf09 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
index 7de0a0737..b408dfb2c 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
index c0aece771..a6f85e921 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
index 1ab07670f..c7b0763e1 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
index a9b1e1be1..bb107d90a 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
index 8c9b42d60..70aa3e212 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
index e220f591f..e67cab8e4 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
index 69e805d1e..313691f32 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
index 2b8cd7096..55fef6a40 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
index 079986685..2946e17f5 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
index b00798b72..ed1bdc44c 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
index 51b3e5d73..ec4e270be 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
index cccbb6011..1f62b1412 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
index c82c28299..68d8aef35 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
index 373bad7d6..c13a62366 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
index 1f9ec2476..1cecd51e2 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
index 06f6e6152..b962782d0 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
index 3d152f604..606fdf426 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.type.synop/endian.pass.cpp b/test/std/utilities/meta/meta.type.synop/endian.pass.cpp
index 865c477e7..65ba30192 100644
--- a/test/std/utilities/meta/meta.type.synop/endian.pass.cpp
+++ b/test/std/utilities/meta/meta.type.synop/endian.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
index bd02da969..903098415 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
index 39a7c2b59..bfd36533e 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
index 755269d1d..74a3637a4 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
index 2d10fb004..af46f4726 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
index f188c098c..25b8d715a 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
index ef1fc4040..1e2dc42ae 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
index 8c8510882..93bf9efb4 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
index 40dea443c..95f71b68a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
index 217bc7e25..c4cf7153b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
index 3f21b9a7d..19ad3e92b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
index a50beeb3e..74977e4b1 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
index dfd09ac52..8611daa15 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
index 3c1a2181d..6eda248f7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
index 2603bdff2..0261581f6 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
index 7e19c0629..78e581a0c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
index 23d517612..0f2304fe7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
index 85c2c9817..ede74445e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
index 41b8d44b9..fe045a297 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
index 9498edc65..7e20b58fc 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
index a63a88c4d..0a1b95354 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
index f57576330..762c21406 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
index 257719eb9..9fa33b93c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
index 89639377c..92e86713c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
index 415d9a781..0fc3c4361 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
index 952a5b748..0bfeaddee 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
index 5154a1d12..b4f010749 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
index f685d71ee..345195e0e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
index cdaf713ac..672a90a6f 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
index 76deef429..2f77553fd 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
index 076204c9c..759eee668 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
index f9c83c67d..68964f526 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
index 23d391b49..cf0b246c6 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
index 36ad00400..683eed65a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
index c7597eb4e..047de2004 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
index f601bd12c..b0ced4a9c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
index 5fa5da12a..bff535c9a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
index dc9e4874a..33807bc4d 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
index 3560b456b..1a1eaee32 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
index fc8a1e5a8..193cf688f 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
index 0bc94583a..d349b75f7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
index 02c539712..ff0ff7a34 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
index d8d5162c1..a0d03dd6e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
index 052b0b985..343b1291a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
index c2804885a..e5486f73e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
index 311215b81..8ec4a6d0f 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
index b546458bd..a511daf35 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
index 39ac07ad4..c20f1e8ef 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
index dd812832f..0ce0423f6 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
index 0df21173c..cc75ef966 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
index a0dea4a9c..ea1302742 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
index de23da836..61ae96e5b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
index b9b28fd8c..63180a008 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
index 05db74c8a..d30354d1a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
index 59569fe08..3559d7b83 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
index 52100c304..d778526b5 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
index 7330f4b35..9ee9bf163 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
index 99ca74cc2..cbc031790 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
index 9c72d4d44..a8f19fd10 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
index 4808a4dc9..eb98ddb54 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
index 616f25180..fdbdfbd59 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
index b90363a5c..f78319aff 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
index 06cf80078..24719bfb8 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
index 684d85d3d..457270a89 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
index 22755dc33..aef79f7fa 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
index 5e8bfeaa4..8722b78fe 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
index 7be76f4fa..6dafb55a3 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
index 5a440598b..61aed970e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
index 7ead5f5d5..80bb49509 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
index 6209bc7b1..edf825dd7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
index e81f8d4f4..3052d3925 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
index 3349a9d3a..c0a22e3b7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
index f36b80cac..e9c256aca 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
index 01c9bd0d0..a3d2611c9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
index 9dbdc4e2a..4caaeca25 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
index 9484b321c..6e443b303 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
index 58e0e0f98..f58a93ce2 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
index 11852f6ae..cb446ef01 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
index b93dbb634..ce002e820 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
index 7510b4e72..c90f938c5 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
index b23a5e45f..2121f75b0 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
index 2ca2b8640..f0dac244c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
index 6ce1c0377..feb8f270e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
index 745efd008..5e9042c79 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
index 6e601c1ac..10f23cca9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
index b17ca76fd..3e0980bd5 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
index c3ae1706f..5d21f3699 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
index a049eab9a..f11f93338 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
index 2d2df14d3..4350f1299 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
index a9b538b2d..a85f57a5e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
index 212245f00..78ae8cfa9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
index 966573c9f..853c8aa32 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
index 2922f2276..decd7ffea 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
index ac4664312..073ea681d 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
index 2d367159c..2f70ba606 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
index 3372e615d..37ea513fc 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
index 9a27c73cd..c4aa7b7dc 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
index 941ff31f8..6f47ed6fd 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
index 376c7e005..86e5611c7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
index cc8d66ae6..28cb29f3b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/nothing_to_do.pass.cpp b/test/std/utilities/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/nothing_to_do.pass.cpp
+++ b/test/std/utilities/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
index 8a7308348..cfae63963 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
index 930015a73..80f2372e4 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
index dc6973927..dbf8a0564 100644
--- a/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
index e1bad12e3..539e35fe0 100644
--- a/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
index 342ddffc2..c7bbbda85 100644
--- a/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
index bcf6afcc6..73ed85643 100644
--- a/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
index 3d5e2144a..c0c111afd 100644
--- a/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
index 7da9b7ba7..949a03a8c 100644
--- a/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp b/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
index e54a4ced8..a842804f3 100644
--- a/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.hash/hash.pass.cpp b/test/std/utilities/optional/optional.hash/hash.pass.cpp
index b4a1832cd..0f74557b7 100644
--- a/test/std/utilities/optional/optional.hash/hash.pass.cpp
+++ b/test/std/utilities/optional/optional.hash/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullops/equal.pass.cpp b/test/std/utilities/optional/optional.nullops/equal.pass.cpp
index a87a87f87..05413c1f1 100644
--- a/test/std/utilities/optional/optional.nullops/equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullops/greater.pass.cpp b/test/std/utilities/optional/optional.nullops/greater.pass.cpp
index 3986a0a92..7bc764d01 100644
--- a/test/std/utilities/optional/optional.nullops/greater.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/greater.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp b/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
index 9f2427273..7c77a95a1 100644
--- a/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp b/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
index 8e73247b9..1d3994e4a 100644
--- a/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullops/less_than.pass.cpp b/test/std/utilities/optional/optional.nullops/less_than.pass.cpp
index 39a8e4a39..3b313c946 100644
--- a/test/std/utilities/optional/optional.nullops/less_than.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/less_than.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp b/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
index 1c96dd42e..9b3c41c1c 100644
--- a/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
index c97bebe29..9cbbc8bd9 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
index 247fce58f..f664433cb 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
index 0fcc52be1..e40af0823 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
index d471c053c..a9a1c07d8 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
index bec0f09a3..8a4540e18 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
index e7f59f1a9..cf09bb5dd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
index f6959c7e9..9141bea11 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
index c41674f13..0c36da93d 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
index 991f43343..e6b67430f 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
index db7fc19bf..d043fd1de 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
index f1e9a1cfd..861ab91d8 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
index ee0dcfd77..462811e51 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
index e12f6cb28..4666d6d9b 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 31e7f9fdb..844abda00 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
index 1e1e82b03..943964241 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
index 6ce35a489..973b49dff 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
index 62795b91f..a00fa1706 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
index 64ac05316..37adf8bbe 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
index 2c6757a95..ea4b7aa50 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
index d0823d2c8..5cd23bad0 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
index 6d9f45a97..f62e6a3a8 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
index 4e3991c18..622b8e428 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index cb084ecd9..afba631bf 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
index 468a00346..850ed6eca 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
index 0e180c14e..fd74f9ae1 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
index f8a98508a..5e9a216dc 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
index 5132c9a73..ca96586a1 100644
--- a/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
index 8fcd18608..e766db87e 100644
--- a/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
index 9820d50f6..29bf20bbd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
index 4087cfdf1..b109346f5 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
index 0779c9047..6663d8851 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
index 78fd99295..02466d53b 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
index 292412323..7dca9f613 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
index 5df295d01..59ce4c7e8 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
index 2f1648c48..ac0b9a527 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
index 887edc711..fd7e683be 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
index f25bf71da..04a4fcffd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
index 6076c509f..ab6504dba 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
index 00f934d6a..dcc9306b1 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
index 90e8fb456..5e218d80e 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
index f94dcabde..93ec45b0b 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
index 36a85811b..0b4c7928f 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
index a63e3be8e..21f630e8c 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
index 26041259f..7d79251e2 100644
--- a/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
index 11ddcb7c0..67e1b76d7 100644
--- a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/special_members.pass.cpp b/test/std/utilities/optional/optional.object/special_members.pass.cpp
index 3bc561cfe..a315ed8ca 100644
--- a/test/std/utilities/optional/optional.object/special_members.pass.cpp
+++ b/test/std/utilities/optional/optional.object/special_members.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/triviality.pass.cpp b/test/std/utilities/optional/optional.object/triviality.pass.cpp
index c21c85aad..7c82e17d6 100644
--- a/test/std/utilities/optional/optional.object/triviality.pass.cpp
+++ b/test/std/utilities/optional/optional.object/triviality.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.object/types.pass.cpp b/test/std/utilities/optional/optional.object/types.pass.cpp
index 0230a13dd..cef295754 100644
--- a/test/std/utilities/optional/optional.object/types.pass.cpp
+++ b/test/std/utilities/optional/optional.object/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.relops/equal.pass.cpp b/test/std/utilities/optional/optional.relops/equal.pass.cpp
index 0752841d3..baeb16bb6 100644
--- a/test/std/utilities/optional/optional.relops/equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp b/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
index f475f3796..3a88640ca 100644
--- a/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.relops/greater_than.pass.cpp b/test/std/utilities/optional/optional.relops/greater_than.pass.cpp
index c3f2af932..7f7b24a75 100644
--- a/test/std/utilities/optional/optional.relops/greater_than.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/greater_than.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.relops/less_equal.pass.cpp b/test/std/utilities/optional/optional.relops/less_equal.pass.cpp
index 35e80d3d4..e9180cb3e 100644
--- a/test/std/utilities/optional/optional.relops/less_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/less_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.relops/less_than.pass.cpp b/test/std/utilities/optional/optional.relops/less_than.pass.cpp
index 1dbffbd92..29fa36a3e 100644
--- a/test/std/utilities/optional/optional.relops/less_than.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/less_than.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.relops/not_equal.pass.cpp b/test/std/utilities/optional/optional.relops/not_equal.pass.cpp
index 12d9922a9..9f690477e 100644
--- a/test/std/utilities/optional/optional.relops/not_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
index 421480aa8..fef17e772 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
index bdfeefbcc..675e90036 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
index e6ed0129d..4a9040e50 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.specalg/swap.pass.cpp b/test/std/utilities/optional/optional.specalg/swap.pass.cpp
index 31779243e..3f37ac6e2 100644
--- a/test/std/utilities/optional/optional.specalg/swap.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp b/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
index 20c90c7e3..aca546d6c 100644
--- a/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
index 57903020f..28904aecf 100644
--- a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp b/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
index 56a30ccb0..4fe41b445 100644
--- a/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
index e4ced3213..d7f775eee 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
index a537f0215..ae43ac922 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
index bdbcda36f..ea96434b8 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
index 49b55e7a6..0b93e1a9c 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
index 81acc14be..b884f4e2c 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
index ccf15e07a..876158994 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
index b88314388..95e9c8239 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
index 33efd90f5..dbb948047 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
index 9331b7094..9f547cdea 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
index 7f7a74068..ab6deac86 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
index db78557ec..79942fa6d 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
index a428be28a..a80112ca4 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
index 7b224ab7c..c5dbdedc8 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
index fcd31207f..68e6aba35 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp b/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
index a7326162f..bb3bb159b 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp b/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
index e6dbf710b..1c143f659 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp b/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
index 753e79af6..bf56271fb 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp b/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
index f4b4ab950..6e44427f8 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp b/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
+++ b/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/ratio/typedefs.pass.cpp b/test/std/utilities/ratio/typedefs.pass.cpp
index 5ab4c740d..3f54f555a 100644
--- a/test/std/utilities/ratio/typedefs.pass.cpp
+++ b/test/std/utilities/ratio/typedefs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp b/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
index 54c2cf16e..cb7a5bbf6 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
index 5d2f955aa..e11ec4b40 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
index 8d83c3c88..b89a45201 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
index 716a2b92a..0800f869f 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
index 3f2ea422d..2b9bdb8c3 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
index 165d48a1c..28ea9d7b0 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
index e1e2e32e2..91349cb30 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
index 7d5e9bca6..e2fe7bb0d 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
index 2a7949f64..3145c0c9f 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
index c102f27fb..f95897b9f 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
index 769deea92..f19943a46 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
index 09e842b59..010c2293a 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
index d747483a9..d269544c3 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 
 //===----------------------------------------------------------------------===//
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
index 8bc8a57c1..e2694b38a 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
index 6764935fe..8d3f94715 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
index 8df259bd4..55a5f48b2 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
index b4cd3f36a..4c5536d93 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
index 781794d41..246af44f9 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
index fa10ade51..e7b916558 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
index f7f209450..cc2a8366e 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
index c95c55b4a..f271a7fb4 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
index 0d067b9ab..98a4125ba 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
index 8f2a69913..e9d43b602 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
index f838661c5..129e3ea45 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
index de18865c5..935ebab7f 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
index 50058a620..0fd37cbfa 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
index b2d3da48d..49cfccb6f 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
index 9a6d6c65f..ce45882a8 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
index 518e31cf9..76f2b4c67 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
index 6a00d14a2..31f33a265 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
index d66af054c..886fc95d9 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
index 8bed9dda2..0bc0c7718 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
index b47c35afb..2b97f8fe5 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
index 529749da6..e5a960a6e 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
index 30b4ecb94..a77194ecf 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
index 009879194..a0e256fcf 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
index cc94e9ab3..0f366c6c3 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
index cfdc2e1d8..90622fed1 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
index 07aa659bd..5c10ac6bb 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
index ace2e4fc7..4adf2e9ae 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
index 9bf794cae..85605a2fc 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
index f686e9f01..c0a10e5e3 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
index 255e5cd39..b09640215 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
index 5d1cf1ff4..d03468c03 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
index 41209d977..699d20ed4 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
index 2949d6310..c2bfd31de 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
index 7a4097664..246cf9d8d 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
index 528b10e90..48ac04552 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
index 22ae217a6..774bc62d2 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
index 88a1e04ba..e1f3e762d 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
index 94ae89ba9..167dd7826 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
index 7ac0ba490..67cb170e4 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
index 8830bf932..821929652 100644
--- a/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
index 0ebf9b0b6..0c88ba36a 100644
--- a/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
index 91e9441fe..f5052b5ef 100644
--- a/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
index be9d54716..a09ce57e3 100644
--- a/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp b/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
index 97ab0c44c..95347a2bc 100644
--- a/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp b/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
index 1d8bff41a..05d286f90 100644
--- a/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/all.pass.cpp
index de1cddb5b..4ac3bae75 100644
--- a/test/std/utilities/template.bitset/bitset.members/all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/any.pass.cpp b/test/std/utilities/template.bitset/bitset.members/any.pass.cpp
index 7ee83dd07..0483a04ff 100644
--- a/test/std/utilities/template.bitset/bitset.members/any.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/any.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/count.pass.cpp b/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
index f6730a4fc..9b66e93e2 100644
--- a/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
index 6d6bcd711..b3f515c0c 100644
--- a/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
index fb47e0cfb..96569e565 100644
--- a/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/index.pass.cpp b/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
index c29ba312a..fb68df5aa 100644
--- a/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp b/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
index 1ac0495da..54a1a31c0 100644
--- a/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp b/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
index 9d630b972..27a20b4f6 100644
--- a/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
index bbbddb9a2..c3becacd3 100644
--- a/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/none.pass.cpp b/test/std/utilities/template.bitset/bitset.members/none.pass.cpp
index 1358eaa62..d5004fbb6 100644
--- a/test/std/utilities/template.bitset/bitset.members/none.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/none.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
index 4f152e3f9..87c3efd1f 100644
--- a/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
index eaac19124..38564bba5 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
index 52157696e..7c428bce0 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
index 98c7ce509..f96c77bc2 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
index a707a7f4d..647c5c028 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
index 69de45e03..ae43bd7e9 100644
--- a/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
index e1bf6b876..ec92f6656 100644
--- a/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp b/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
index 554abde32..a94f9bf09 100644
--- a/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
index 8e5edbe38..387f68249 100644
--- a/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
index 45bc2b9ca..68f8c58bb 100644
--- a/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
index e46ed978d..f660a4409 100644
--- a/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/size.pass.cpp b/test/std/utilities/template.bitset/bitset.members/size.pass.cpp
index 822e0a048..f1719ab2e 100644
--- a/test/std/utilities/template.bitset/bitset.members/size.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/test.pass.cpp b/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
index 4a1c0e23b..df3ee16be 100644
--- a/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
index 37824d81b..d89794472 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
index 20578511c..1ea9b0f81 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
index 0872d77bc..71910f322 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
index e58c72016..af69d3951 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
index 244a2ba54..8d9b2bdfb 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
index e601b26cf..c2cada15e 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
index 4c8afe3f9..714fcd3ed 100644
--- a/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
index 05efe27fa..06a36604a 100644
--- a/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/template.bitset/includes.pass.cpp b/test/std/utilities/template.bitset/includes.pass.cpp
index 021ca28e6..c98b150e7 100644
--- a/test/std/utilities/template.bitset/includes.pass.cpp
+++ b/test/std/utilities/template.bitset/includes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/clock.h b/test/std/utilities/time/clock.h
index c72470c9c..3a637ee14 100644
--- a/test/std/utilities/time/clock.h
+++ b/test/std/utilities/time/clock.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/date.time/ctime.pass.cpp b/test/std/utilities/time/date.time/ctime.pass.cpp
index f6dd75d24..3fa04b779 100644
--- a/test/std/utilities/time/date.time/ctime.pass.cpp
+++ b/test/std/utilities/time/date.time/ctime.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/days.pass.cpp b/test/std/utilities/time/days.pass.cpp
index 14ab01a65..a22f97b8f 100644
--- a/test/std/utilities/time/days.pass.cpp
+++ b/test/std/utilities/time/days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/hours.pass.cpp b/test/std/utilities/time/hours.pass.cpp
index e4c39f785..e04888f2e 100644
--- a/test/std/utilities/time/hours.pass.cpp
+++ b/test/std/utilities/time/hours.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/microseconds.pass.cpp b/test/std/utilities/time/microseconds.pass.cpp
index 1fe6b10da..20e12a9a2 100644
--- a/test/std/utilities/time/microseconds.pass.cpp
+++ b/test/std/utilities/time/microseconds.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/milliseconds.pass.cpp b/test/std/utilities/time/milliseconds.pass.cpp
index 75df301f7..6183b929f 100644
--- a/test/std/utilities/time/milliseconds.pass.cpp
+++ b/test/std/utilities/time/milliseconds.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/minutes.pass.cpp b/test/std/utilities/time/minutes.pass.cpp
index 14214861c..413d8cd6f 100644
--- a/test/std/utilities/time/minutes.pass.cpp
+++ b/test/std/utilities/time/minutes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/months.pass.cpp b/test/std/utilities/time/months.pass.cpp
index 63f85623e..ff40823f1 100644
--- a/test/std/utilities/time/months.pass.cpp
+++ b/test/std/utilities/time/months.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/nanoseconds.pass.cpp b/test/std/utilities/time/nanoseconds.pass.cpp
index d422803f4..c14389da7 100644
--- a/test/std/utilities/time/nanoseconds.pass.cpp
+++ b/test/std/utilities/time/nanoseconds.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/rep.h b/test/std/utilities/time/rep.h
index 1c76582d3..f54eef3ef 100644
--- a/test/std/utilities/time/rep.h
+++ b/test/std/utilities/time/rep.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/seconds.pass.cpp b/test/std/utilities/time/seconds.pass.cpp
index 231d59695..bd2d6d2b3 100644
--- a/test/std/utilities/time/seconds.pass.cpp
+++ b/test/std/utilities/time/seconds.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.cal/euclidian.h b/test/std/utilities/time/time.cal/euclidian.h
index cc7e054ac..de56477ae 100644
--- a/test/std/utilities/time/time.cal/euclidian.h
+++ b/test/std/utilities/time/time.cal/euclidian.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp b/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
index dd36ee574..3a3978cb0 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
index a3ac8dc46..c53af6511 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
index aa084e863..b26d2285a 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
index 54b18e34b..8a04298ab 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
index aed46e7d7..42f12af55 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
index 1047e1bc3..6b8a42772 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
index 350a84635..36352fa35 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
index 405200e47..b3febd4eb 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
index 47ef42c07..4953d1afe 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
index b08d6ef4b..10cec0a62 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
index 9c949170a..ad3d4f3f9 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
index 06b70b0aa..d437a6ae3 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
index 5d8512058..10396919b 100644
--- a/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
index 743da74ba..f3dadd2f6 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
index 5bc001c47..c9c247d50 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
index 96806fda8..e1b46190f 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
index d715635d4..649f09968 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
index c8938be08..c186f594c 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
index 46ae31aaf..dbebdfa7d 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
index 988e43323..ba7c336a6 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
index c3bc1777d..ba9eda73a 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
index 5ae329440..4bf983f3b 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
index 421f9e7b0..b9945b6d8 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
index 85955c819..38c52e229 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
index 3c2da00e8..ebb915598 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
index de15cabd0..e3f02a885 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
index 5e86f58ec..d0ed4d37d 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
index b6d4848fb..2cab328cf 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
index 2309490ab..81162edf6 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
index 3382a6378..7cb5edad4 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
index 1e5a045ed..7ca4a6e5f 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
index 21c6e0027..aa37fde3b 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
index 2721a9766..807cf2988 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
index 1329a9f95..291d299e3 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
index 749635f81..87b39003b 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
index abc2c1edc..5f3f3884f 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
index af7532c7b..b3e502465 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
index 445b86dde..8d0b560b1 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
index f915b6deb..99bdcb160 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
index 11d9e2876..b4999652f 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
index 3eb67259c..d80ae29d0 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
index 21779843a..64df8840e 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
index 3858731f5..e7981b571 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
index 86479d8ca..67c3f17b9 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
index 2dd64eb80..fa5ca0443 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
index 155e030ff..3561651c2 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
index b464fec33..10245f938 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
index 1a687d962..4afa6cca7 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
index b3cd5ec2b..4d0e935f1 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
index 4e06812e0..2bf0e1ec4 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
index 43982f4b4..2271f42c0 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
index 146a0f180..e51fb4fa4 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
index f3f39c0dc..27043b88c 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
index 54b494268..4dc6db768 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
index 516e0f182..25d25b26d 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
index 62e1c3ace..6ef320ebb 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
index d2dfc1321..a8df70096 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
index dc884638d..2556bb93f 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
index 56d88ca7c..af27c945e 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
index 84ea86c22..ff467aa60 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
index 7a9cfd2d6..b9facef63 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
index 5a29087f2..043a98acc 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
index e711426cd..1cdfb29c9 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
index da975ffc4..47f50b6d6 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
index 2381322fa..963f9f15e 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
index 0e5f77dd7..810b2cb0c 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
index a21ae0dc5..74634da8a 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
index 1ea5196ad..f7fa66320 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
index 4bd0f6c2c..d708a8124 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
index 403ce0cf7..48767b3b8 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
index 59ab4da08..1a9fc97eb 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
index 65d0eed4a..efb598472 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
index f6c191329..c986f99c3 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
index 235138235..ee241c8e7 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
index f6bfc2192..9ec3afb21 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
index c49d05d3a..920b53e78 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
index 74774b6a0..c8b023a37 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
index 945d97f49..d9239ff8f 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
index 5b03b181c..f8bd9d43a 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
index 1498d2748..aa0f3f7e5 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
index 27c14a55a..e0963540c 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
index 0142feee8..c042ac147 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
index 16f9899d6..8f713aad2 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
index ca126e9dc..2bf0ed789 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
index bb9145a65..287834cd7 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
index cf28397a3..aef5a82e7 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
index 0a3a89406..ed355b025 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
index 904e722db..5f8b4660a 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
index 810b28d9b..e8473bf98 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
index a6b60d6a0..759fb6661 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
index 73c0adb98..b1785b86c 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
index 5f38b4c8c..dfc2ad3ff 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
index c74b5f801..65b149458 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
index b457b7e91..a00a36f2d 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
index 70bf9e11a..8d675f4db 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
index 1d757ec08..c6138c7af 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
index 0661567d8..6ebd0e66f 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
index 04cf9f617..3e3e0b77d 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
index dfb3c5f98..15c713def 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
index 4bc92df21..2c52cde0a 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
index 92094b0c2..10bea23a0 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
index 4a1cc9087..090a1ac21 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
index 7a6dba18b..97334b205 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
index 7e84b37ab..54e67dff9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
index 44648c4a0..76f3b3355 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
index 073a28656..05cd60844 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
index 88e28026a..e8476b042 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
index d0c8d1e8c..e1ab033c7 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
index 1f77811ac..2999560f1 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
index 67616764d..dc721adee 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
index 8679c9612..e75fc21bf 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
index 200e2874d..a3b9999f8 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
index 5c7de1418..9cebaa683 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
index e2e0ac38c..a5818849a 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
index 36a6c7d18..7344c10c1 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
index a8d6526b3..913b40395 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
index c46b9ce85..12e1515b1 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
index b3c03041e..8c091d051 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
index cab0599b9..edb55f58b 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
index a70fe30fc..02212dc90 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
index 4e263bccc..5925cb0cb 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
index 7cd31222d..173b8b6a2 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
index 650941dc9..1d9951291 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
index be6aa5c57..465fa9d93 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
index 0df684395..8d5bf8955 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
index 41b61f7b6..4d5625ba7 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
index c325d1f89..2913eb237 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
index 4bfca1549..cce42bc61 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
index f13f4da1a..c61d1c996 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
index e2a6a7acf..d27c3c67e 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
index db3369c6c..24682b695 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
index 43ec42d94..cf1024a8c 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
index 613cc1c6b..5c99d9471 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
index 7b61214b7..bb4c410d4 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
index 45f1ac4ae..83f8b70dc 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
index 20aff6d1d..9a32112c9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
index bfa1d58d9..2c4d1ff1f 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
index ce364d236..00335e15d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
index 0f4da09dc..49387091d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
index d4e4a1185..9db4b6aa6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
index 1c8d4e7af..7f5a796df 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
index 25ab85d8f..c494620df 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
index 06c752e29..268eb88fe 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
index a0b98abb7..0eae24e45 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
index 751de6091..dab8b2157 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
index b9d3b6c62..96261c54e 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
index 5a29b8218..4c0bc13c1 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
index 5749da9af..0e2d41a77 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
index 97f898986..f66d6a083 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
index ef30ce526..788af6535 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
index 04986e50d..111cf5f38 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
index c5e101250..7e20a8eb0 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
index 86830249e..4deee9bc3 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
index ad9bc6ee6..1b9c8ad10 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
index 52d918e55..4a9832323 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
index 5cf1cbaf7..8103c28aa 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
index fc13709cd..847699b25 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
index 0b217414c..ff472fdc6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
index 50572c0c4..bc72d958c 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
index f985f46ea..eb92cf05e 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
index 8969bd32a..449098c4f 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
index cd3f112ac..1db6850db 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
index f0c7ec488..7b95084b2 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
index d9443d34b..1cffb4565 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
index 45f1ac4ae..83f8b70dc 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
index c5abe4ace..cc3da2992 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
index d416f6b2b..ad513c5d0 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
index 8793c659a..7d9255fe4 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
index 83640302f..cc0521354 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
index fb621afcd..4011f0673 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
index 6af54892a..a13b11f8c 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
index c0ca34e83..20a58152f 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
index 9f8eb9dc0..45dd7562d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
index 46b6ebaed..6e4409c71 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
index a7f3f024e..e0580fac7 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp b/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp b/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
index 0b5757f67..332d8163c 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
index 955e3ebe9..75652f3ec 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
index 69dfa9180..3b51b91b5 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
index c0fa0b5be..c36649a5d 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
index 47a610f00..6f06e718e 100644
--- a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
index ab67cd838..c1d879c6f 100644
--- a/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
index e5e6de260..1577bc180 100644
--- a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
index 4b86d9e8c..248f1523f 100644
--- a/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
index c5ecb3227..b15a8e212 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
index f4a454f57..e6acef241 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
index 9f91ca744..398cdb9d7 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
index ebc0db80b..00a163685 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
index b6a440e16..cae8375d8 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
index 299e06818..516f54914 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
index c4028063b..0819a7b54 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/default_ratio.pass.cpp b/test/std/utilities/time/time.duration/default_ratio.pass.cpp
index a34e27832..92c015eef 100644
--- a/test/std/utilities/time/time.duration/default_ratio.pass.cpp
+++ b/test/std/utilities/time/time.duration/default_ratio.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/duration.fail.cpp b/test/std/utilities/time/time.duration/duration.fail.cpp
index 053616b79..94e239c1f 100644
--- a/test/std/utilities/time/time.duration/duration.fail.cpp
+++ b/test/std/utilities/time/time.duration/duration.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/positive_num.fail.cpp b/test/std/utilities/time/time.duration/positive_num.fail.cpp
index e9096fd3f..6e78f7765 100644
--- a/test/std/utilities/time/time.duration/positive_num.fail.cpp
+++ b/test/std/utilities/time/time.duration/positive_num.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/ratio.fail.cpp b/test/std/utilities/time/time.duration/ratio.fail.cpp
index 4ce0aaad0..21873788a 100644
--- a/test/std/utilities/time/time.duration/ratio.fail.cpp
+++ b/test/std/utilities/time/time.duration/ratio.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp b/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
index 221004c56..6331dc95a 100644
--- a/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp b/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
index 30ea029b7..5cb52ba76 100644
--- a/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
index 416a8db8a..9d6566a08 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
index deb4daa8d..78beffe26 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
index 37753bcad..0b8f49fc3 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
index b74011a3b..0e907b573 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
index 98b22a7b1..c9f1278a3 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
index a908c44dd..5abecee16 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
index f932eb51c..f7ab6d2e2 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
index 185db1778..1752d5257 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
index 4ae774b6c..4f79398f7 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
index 194e085ab..89b550d01 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
index 7dcf00225..8ef16c7ff 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
index f3bf79035..b4b76fb6f 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
index 909e85732..e557bc21f 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
index 8d7623c85..b509182c4 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
index 9ecdfc750..5187d3d0e 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
index 14d9ca878..62dd5a51d 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
index 38db42a84..29142bdcf 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
index 6f9f5bd29..aadfbfdc4 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
index 2f9689007..b0789b791 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
index 13dd8f44c..a46aa526b 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp b/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
index 5adc62ff1..912d22fdf 100644
--- a/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp b/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
index 42e798254..9eea6ceb3 100644
--- a/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
index c237fd771..0f6fb8d35 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
index 04c082578..b35c01c40 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
index e82e25e8f..b66b2f3c6 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
index 4b5042df2..5624327ba 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
index 8e5938b9e..a63471bc3 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
index 74b65d6b9..68484d1fb 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
index 4f7d67bb6..9edcd46f9 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
index 6ad743e71..f89263bf9 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
index 9f071ca1a..fc6f5700a 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
index 37f32e776..bdbe7211b 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
index ae745a76f..3ecb76135 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
index 4ace54b23..831370994 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
index e10b35efb..13ad165b7 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
index 52208cb54..025100c59 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
index 6e43e3a9a..9ca290867 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
index f190d7863..5c38db527 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
index 282b1c657..407091032 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
index 6859ffcb2..30aa62cd9 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
index 4bf26e428..cb0a53fdf 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
index 4c4895b2a..40f521bae 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
index db725773f..41c55fcca 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
index 8b667e84d..8718ad757 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
index 441b053dc..7a2063ca5 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
index 16e511d44..3ee0578f8 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
index 537fae373..6d7e285d9 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
index 6b8c83732..19e33366f 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
index d8160500f..6ad3c7928 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
index e224ba942..5cc717c5c 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp b/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
index 275f87760..c6f3f1e65 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
index daf7165cf..b16e608dc 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
index a43bb099f..f3065c305 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.duration/types.pass.cpp b/test/std/utilities/time/time.duration/types.pass.cpp
index 8eaffe776..9e5abbc20 100644
--- a/test/std/utilities/time/time.duration/types.pass.cpp
+++ b/test/std/utilities/time/time.duration/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/default_duration.pass.cpp b/test/std/utilities/time/time.point/default_duration.pass.cpp
index dfdf225ed..e645e2970 100644
--- a/test/std/utilities/time/time.point/default_duration.pass.cpp
+++ b/test/std/utilities/time/time.point/default_duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/duration.fail.cpp b/test/std/utilities/time/time.point/duration.fail.cpp
index ee48bcb39..a4881acc9 100644
--- a/test/std/utilities/time/time.point/duration.fail.cpp
+++ b/test/std/utilities/time/time.point/duration.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp b/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
index d60f6276a..999071b72 100644
--- a/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp b/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
index 9ef952559..3d62cdeda 100644
--- a/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
index 1c92d75b9..4a90ec870 100644
--- a/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
index e6e7c0538..efd2a3e59 100644
--- a/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
index ea48e1219..c5dfba6c4 100644
--- a/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
index efd2d9e25..db2391d25 100644
--- a/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
index 53c14f47d..6c6f9c5bf 100644
--- a/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
index b5d16cf11..e68e23396 100644
--- a/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
index ae5423ef1..5779ef920 100644
--- a/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
index de1e5bb3e..9e1f903b9 100644
--- a/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
index f5ff11958..e2b3508e0 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
index a6f7cc0b8..cc2ef3337 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
index f9745cbf9..04f7639d6 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
index d7adf29f2..57d24d08d 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp b/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
index 565aa6c4f..a68d4b0f3 100644
--- a/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp b/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
index 33e349fe8..91bcebb1a 100644
--- a/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp b/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
index 120fd3fb4..2deb8ae29 100644
--- a/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp b/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
index 810007ed9..4a42eef30 100644
--- a/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp b/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
index 1b96902ab..0830eea91 100644
--- a/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp b/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
index 19f5cbcd9..df6c69157 100644
--- a/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp b/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
index 978f09d66..876d42d56 100644
--- a/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp b/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
index fcef3f249..851869d4d 100644
--- a/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp b/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.special/max.pass.cpp b/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
index 85447ea41..c8f2d41be 100644
--- a/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.point/time.point.special/min.pass.cpp b/test/std/utilities/time/time.point/time.point.special/min.pass.cpp
index fab5b4aae..1cac23062 100644
--- a/test/std/utilities/time/time.point/time.point.special/min.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.special/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp b/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp b/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
index bd4115437..f44a7964f 100644
--- a/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp b/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
index 207a9ab5a..c64746d9f 100644
--- a/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp b/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
index 614c69b2e..6eec47ce3 100644
--- a/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp b/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
index faacb573d..cf588f5c0 100644
--- a/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp b/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
index f942844b6..39afe6a5f 100644
--- a/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp b/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
index a0786b499..bf880fcd2 100644
--- a/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/time/weeks.pass.cpp b/test/std/utilities/time/weeks.pass.cpp
index 8e6f283f0..2231c6955 100644
--- a/test/std/utilities/time/weeks.pass.cpp
+++ b/test/std/utilities/time/weeks.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/time/years.pass.cpp b/test/std/utilities/time/years.pass.cpp
index 28a250274..c2229caee 100644
--- a/test/std/utilities/time/years.pass.cpp
+++ b/test/std/utilities/time/years.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
diff --git a/test/std/utilities/tuple/tuple.general/ignore.pass.cpp b/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
index a7a0904cf..d216c19fc 100644
--- a/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
index 811dfc03b..326d7bb58 100644
--- a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
index 977d2b6da..b9e6e111c 100644
--- a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/alloc_first.h b/test/std/utilities/tuple/tuple.tuple/alloc_first.h
index 237a2897e..3db836a42 100644
--- a/test/std/utilities/tuple/tuple.tuple/alloc_first.h
+++ b/test/std/utilities/tuple/tuple.tuple/alloc_first.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/alloc_last.h b/test/std/utilities/tuple/tuple.tuple/alloc_last.h
index 71a9b9e97..76f69e137 100644
--- a/test/std/utilities/tuple/tuple.tuple/alloc_last.h
+++ b/test/std/utilities/tuple/tuple.tuple/alloc_last.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
index 4c15499f5..2daef09fb 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
index 02d7fe43e..978c923ef 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
index 33c3ef595..138f074b2 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
index bd91ce61b..6afd88825 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
index a66fba22d..bf4a8cc0d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
index 85dcee893..e21118a2f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
index 1a32acd55..95b1e2769 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
index 5911391d6..167d442b7 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
index edb235a41..5162c4053 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
index 9bc0ef501..4545cf4df 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
index 27656a675..2dec9fffa 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
index 08d1304f9..5e31090c9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
index bfa7c0d23..b6e444c65 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
index 0d3b7ff24..79064fb09 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
index a5b3d4415..8992f7b82 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
index c8b722f83..9f8658aa6 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
index dd9b83242..b0dd392f1 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
index b9497bea5..3a0e0f888 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
index fed27aa84..f43e6d8bc 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
index bf66da162..e4ed47690 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
index e174e9b32..99155823b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
index b28ad6dab..1759ba4f3 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
index 73d53a4c0..10647a49d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
index 1d0c7b49a..baafee879 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
index ccf08833b..8d0482859 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
index 153cd2b3d..bcece6098 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
index d3539cebf..ed485c901 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
index d3a6add5d..e86ec8aea 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
index 7c9f60cbf..19829a967 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
index a3e1a9de6..c77484de5 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
index 03e9ab2f6..3da2d8a46 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
index b72f0fc2e..2a405c1a4 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
index 0da132fcf..955a83a6e 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
index 68b3fbd0d..35e82277f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
index bed161a3d..0fd29b22f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
index 4609b0425..98d002b80 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
index 2af86fdd0..79332841e 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
index 1937f49ef..f82dc6b1f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
index 1137df291..7c581cb77 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
index 731946608..15bcde7e9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
index b4fd2e264..1d4779aae 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
index 85036b591..ea393abaf 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
index 1cc13cf58..98a12a972 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
index 13558f3fb..3953ee150 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
index 76f7e794a..248685156 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
index c069a0ba2..b84dba378 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
index 1099e3579..5a7940da6 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
index 2c38bf7d2..3f0dae093 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
index 5dc98afe6..f703ef2c8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
index 18095f7e3..927fc2ab8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
index 490283e7a..4c0b5a6b4 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
index f01491674..5ca0bd8e9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
index 9c2d992b8..373d84bad 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
index 720a90640..4c2654cd7 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
index fc5341289..3708e5cb0 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
index 6c456d430..114672b7c 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
index af9424806..f85c8098f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
index 01ee1ca1f..9df8ce381 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
index 57da4b04c..e56f86a1c 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
index bd015ab5b..eb1704c94 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
index 4cb73573e..a1c42921b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
index 5beedbe9d..ecb6ea087 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
index 3f132e47b..aa2081839 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
index 49b4215a1..2a602b1ca 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
index 05ff8a4df..3d0925068 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
index c4f2e52ab..44e100c6d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
index a18b9fc89..f191f9f64 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
index 957a683b4..820cb0443 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
index 24878a1d5..b2b3e72b9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
index 31ebe5878..9c0041876 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
index a802a05da..709f747c7 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
index f4d764b87..9f29c6c4a 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
index dcae60612..079977016 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
index 6749f592a..097f69b42 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
index ddaf52fea..5e4722874 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp b/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
index 26bada38f..daa287e3e 100644
--- a/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.hash/hash.pass.cpp b/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
index 14bf08412..139847fda 100644
--- a/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
+++ b/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.members/ctor.pass.cpp b/test/std/utilities/type.index/type.index.members/ctor.pass.cpp
index e5183eb87..cafeebb09 100644
--- a/test/std/utilities/type.index/type.index.members/ctor.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.members/eq.pass.cpp b/test/std/utilities/type.index/type.index.members/eq.pass.cpp
index b6bbd1d23..210d0ab02 100644
--- a/test/std/utilities/type.index/type.index.members/eq.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/eq.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp b/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
index b4f316830..f5b6cc35c 100644
--- a/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.members/lt.pass.cpp b/test/std/utilities/type.index/type.index.members/lt.pass.cpp
index c099d1c56..1f631b7b9 100644
--- a/test/std/utilities/type.index/type.index.members/lt.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/lt.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.members/name.pass.cpp b/test/std/utilities/type.index/type.index.members/name.pass.cpp
index 44ee21519..1b01f52f9 100644
--- a/test/std/utilities/type.index/type.index.members/name.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/name.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp b/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
index 234e26b49..b7fbb6f91 100644
--- a/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
+++ b/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp b/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
index 499c4b63b..9520cd8f6 100644
--- a/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
+++ b/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp b/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
index 9ab58ea6c..333e04b18 100644
--- a/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
+++ b/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utilities.general/nothing_to_do.pass.cpp b/test/std/utilities/utilities.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utilities.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utilities.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/as_const/as_const.fail.cpp b/test/std/utilities/utility/as_const/as_const.fail.cpp
index c28957cfc..5f3b78b72 100644
--- a/test/std/utilities/utility/as_const/as_const.fail.cpp
+++ b/test/std/utilities/utility/as_const/as_const.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/as_const/as_const.pass.cpp b/test/std/utilities/utility/as_const/as_const.pass.cpp
index 268f2d1b0..284e5b7b3 100644
--- a/test/std/utilities/utility/as_const/as_const.pass.cpp
+++ b/test/std/utilities/utility/as_const/as_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/declval/declval.pass.cpp b/test/std/utilities/utility/declval/declval.pass.cpp
index aabd0e6f6..b298d58a0 100644
--- a/test/std/utilities/utility/declval/declval.pass.cpp
+++ b/test/std/utilities/utility/declval/declval.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/exchange/exchange.pass.cpp b/test/std/utilities/utility/exchange/exchange.pass.cpp
index 1a5007ea4..1defcbfb3 100644
--- a/test/std/utilities/utility/exchange/exchange.pass.cpp
+++ b/test/std/utilities/utility/exchange/exchange.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/forward/forward.fail.cpp b/test/std/utilities/utility/forward/forward.fail.cpp
index c845216d8..a689b1d0d 100644
--- a/test/std/utilities/utility/forward/forward.fail.cpp
+++ b/test/std/utilities/utility/forward/forward.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/forward/forward.pass.cpp b/test/std/utilities/utility/forward/forward.pass.cpp
index afff8d627..394c016e2 100644
--- a/test/std/utilities/utility/forward/forward.pass.cpp
+++ b/test/std/utilities/utility/forward/forward.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/forward/forward_03.pass.cpp b/test/std/utilities/utility/forward/forward_03.pass.cpp
index 7e141bad9..c5a2507a7 100644
--- a/test/std/utilities/utility/forward/forward_03.pass.cpp
+++ b/test/std/utilities/utility/forward/forward_03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/forward/move.fail.cpp b/test/std/utilities/utility/forward/move.fail.cpp
index bd2126cba..bd8fd46a9 100644
--- a/test/std/utilities/utility/forward/move.fail.cpp
+++ b/test/std/utilities/utility/forward/move.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/forward/move.pass.cpp b/test/std/utilities/utility/forward/move.pass.cpp
index e2edc2a2a..c98efa1c3 100644
--- a/test/std/utilities/utility/forward/move.pass.cpp
+++ b/test/std/utilities/utility/forward/move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp b/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
index bc60d3d27..52a276c24 100644
--- a/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
+++ b/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/operators/rel_ops.pass.cpp b/test/std/utilities/utility/operators/rel_ops.pass.cpp
index 26e766592..9c8dbedcc 100644
--- a/test/std/utilities/utility/operators/rel_ops.pass.cpp
+++ b/test/std/utilities/utility/operators/rel_ops.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp b/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
index dbe1c2668..e14a1c46a 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
index c09c8815e..2b164deb4 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
index 5c38318d2..05c81a23b 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
index 2f8b6c1e8..45fb7aa79 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
index 0601e4e73..9ca7b4df6 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
index f4a623226..99fb2cd22 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
index f0d55a661..bba71cb8d 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
index 72e637592..c79e0788c 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
index d5179e435..4787d0e2e 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
index 4ca31f7de..ba571fda1 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
index 5ac838b37..4ba581434 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
index 3756e963f..a88b84596 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp b/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
index 12968de2d..72eb31208 100644
--- a/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp b/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
index b58f5c55b..f77636c84 100644
--- a/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
index 1ef2d9402..11403c91d 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
index 90722c393..5af432b99 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
index 3f7066310..db671a150 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
index cf1afff90..53cc49183 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
index f02e24b24..91427ca7f 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
index b7a89a844..7248c2ffa 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
index bf19d1abe..fcaa44849 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
index 8c56c2003..4759303d6 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
index d2cb6b109..c9c733d8c 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
index fbf461f9b..8a3fca758 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
index 1003f3c8b..bee96000e 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
index d5e1e232f..b3a248c88 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
index af91abe74..9a07814b1 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
index b25099f4d..df9cbc757 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
index 7933dd99c..4b7529388 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
index 99e00b025..92a0aa42b 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp b/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
index 3704dcc32..325499eaf 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
index aa86949dd..3c93eeb3d 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
index 7e40bed21..b38ca2a3b 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
index 1331a3153..48ea5fac6 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
index 95b1f66d6..58a5c2932 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
index 200f044c6..e4b444a34 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
index c16bd71ff..abda1d8c3 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/synopsis.pass.cpp b/test/std/utilities/utility/synopsis.pass.cpp
index 009b65cbb..90c5e3218 100644
--- a/test/std/utilities/utility/synopsis.pass.cpp
+++ b/test/std/utilities/utility/synopsis.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/utility.inplace/inplace.pass.cpp b/test/std/utilities/utility/utility.inplace/inplace.pass.cpp
index e87c6f399..53fa3cf66 100644
--- a/test/std/utilities/utility/utility.inplace/inplace.pass.cpp
+++ b/test/std/utilities/utility/utility.inplace/inplace.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/utility.swap/swap.pass.cpp b/test/std/utilities/utility/utility.swap/swap.pass.cpp
index c9c9f3b52..9dda5a42c 100644
--- a/test/std/utilities/utility/utility.swap/swap.pass.cpp
+++ b/test/std/utilities/utility/utility.swap/swap.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/utility/utility.swap/swap_array.pass.cpp b/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
index ad39934b2..202e8d33f 100644
--- a/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
+++ b/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
index 4e76e12b9..1585e1745 100644
--- a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
+++ b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp b/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
index 8fb3817db..0c118a0f5 100644
--- a/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.get/get_if_index.pass.cpp b/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
index 94cc08031..505a8cb8e 100644
--- a/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.get/get_if_type.pass.cpp b/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
index a8cc664ef..3cb0fc705 100644
--- a/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.get/get_index.pass.cpp b/test/std/utilities/variant/variant.get/get_index.pass.cpp
index dd76fa6c7..a5a629adb 100644
--- a/test/std/utilities/variant/variant.get/get_index.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_index.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.get/get_type.pass.cpp b/test/std/utilities/variant/variant.get/get_type.pass.cpp
index 7b4a67048..b4cae1027 100644
--- a/test/std/utilities/variant/variant.get/get_type.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_type.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp b/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
index 103b04981..3e9cfbe9c 100644
--- a/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
+++ b/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp b/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
index 826dcbae6..404f3e7e5 100644
--- a/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.hash/hash.pass.cpp b/test/std/utilities/variant/variant.hash/hash.pass.cpp
index 2ad2184f4..5acf168ad 100644
--- a/test/std/utilities/variant/variant.hash/hash.pass.cpp
+++ b/test/std/utilities/variant/variant.hash/hash.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
index 31521dae2..f7db0d86b 100644
--- a/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
+++ b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp b/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
index 84689a050..841f65cb1 100644
--- a/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
+++ b/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp b/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
index 2085fa56e..f7e200b24 100644
--- a/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
+++ b/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp b/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
index 49abba295..2df4b2bac 100644
--- a/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
+++ b/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.monostate/monostate.pass.cpp b/test/std/utilities/variant/variant.monostate/monostate.pass.cpp
index 76cddf900..1d7bcaca4 100644
--- a/test/std/utilities/variant/variant.monostate/monostate.pass.cpp
+++ b/test/std/utilities/variant/variant.monostate/monostate.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.relops/relops.pass.cpp b/test/std/utilities/variant/variant.relops/relops.pass.cpp
index 41a953552..1950b5a38 100644
--- a/test/std/utilities/variant/variant.relops/relops.pass.cpp
+++ b/test/std/utilities/variant/variant.relops/relops.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp b/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
index ab68bc420..d03a6b5d5 100644
--- a/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
+++ b/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp b/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
index 4d7c8563c..aadda7eac 100644
--- a/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
+++ b/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
index 6c8a2b86a..67deb3f2c 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index 5ea7069f5..6a59989dd 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index cee141a8c..833883d29 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
index d414c3503..7357b9b56 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index 6eeec69c8..b6471052f 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
index e4278f0e0..ec6eb289b 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
index 0e1ba7bba..a268adcea 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
index 7dcd2541b..9c7e3faf8 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
index c798efbaa..05b2a29ce 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
index 7d632af9a..c3f3e58d3 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index f59367109..ecb4a7207 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp b/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
index 7299394ee..8ced5321b 100644
--- a/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
index d281927c7..ea84ac940 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
index 939e8f39d..13e3c927c 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
index 4fed14167..7c9034f10 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
index f03e95644..85cd25d04 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp b/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
index 6d78de3a4..0afa10138 100644
--- a/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp b/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
index 9ccdc2221..147f380a1 100644
--- a/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
index ec85ce767..e05cd13e6 100644
--- a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant_array.fail.cpp b/test/std/utilities/variant/variant.variant/variant_array.fail.cpp
index 11ee332e2..a9caeb8b2 100644
--- a/test/std/utilities/variant/variant.variant/variant_array.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_array.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp b/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
index 2d8cc0b3d..85a10eff9 100644
--- a/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp b/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
index bda27f0e5..e659f4760 100644
--- a/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.variant/variant_void.fail.cpp b/test/std/utilities/variant/variant.variant/variant_void.fail.cpp
index 3d0da5620..ce0675d73 100644
--- a/test/std/utilities/variant/variant.variant/variant_void.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_void.fail.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/utilities/variant/variant.visit/visit.pass.cpp b/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 693369abb..198f310e9 100644
--- a/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/Counter.h b/test/support/Counter.h
index 63ed60801..8dbdaeb36 100644
--- a/test/support/Counter.h
+++ b/test/support/Counter.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/DefaultOnly.h b/test/support/DefaultOnly.h
index a3d4303f8..2e9e7029c 100644
--- a/test/support/DefaultOnly.h
+++ b/test/support/DefaultOnly.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/MoveOnly.h b/test/support/MoveOnly.h
index 2eba8e742..5611ebbdd 100644
--- a/test/support/MoveOnly.h
+++ b/test/support/MoveOnly.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/allocators.h b/test/support/allocators.h
index 00e9a0c13..eae51909e 100644
--- a/test/support/allocators.h
+++ b/test/support/allocators.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/any_helpers.h b/test/support/any_helpers.h
index ec8654d19..eb9a4c149 100644
--- a/test/support/any_helpers.h
+++ b/test/support/any_helpers.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef ANY_HELPERS_H
diff --git a/test/support/asan_testing.h b/test/support/asan_testing.h
index 678f12a91..6171d0bee 100644
--- a/test/support/asan_testing.h
+++ b/test/support/asan_testing.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/charconv_test_helpers.h b/test/support/charconv_test_helpers.h
index 1560fa79a..dc704a925 100644
--- a/test/support/charconv_test_helpers.h
+++ b/test/support/charconv_test_helpers.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/cmpxchg_loop.h b/test/support/cmpxchg_loop.h
index 5bec51b63..50bd00a30 100644
--- a/test/support/cmpxchg_loop.h
+++ b/test/support/cmpxchg_loop.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/container_test_types.h b/test/support/container_test_types.h
index 1c4625b9f..2668aa889 100644
--- a/test/support/container_test_types.h
+++ b/test/support/container_test_types.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_CONTAINER_TEST_TYPES_H
diff --git a/test/support/controlled_allocators.hpp b/test/support/controlled_allocators.hpp
index f0d615c35..63a4c402b 100644
--- a/test/support/controlled_allocators.hpp
+++ b/test/support/controlled_allocators.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/coroutine_types.h b/test/support/coroutine_types.h
index f592bedca..e5d40b1fc 100644
--- a/test/support/coroutine_types.h
+++ b/test/support/coroutine_types.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/count_new.hpp b/test/support/count_new.hpp
index e3111e7a5..5601c0054 100644
--- a/test/support/count_new.hpp
+++ b/test/support/count_new.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/counting_predicates.hpp b/test/support/counting_predicates.hpp
index a0b3ca518..1868d30b4 100644
--- a/test/support/counting_predicates.hpp
+++ b/test/support/counting_predicates.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/debug_mode_helper.h b/test/support/debug_mode_helper.h
index 350deb083..611b4dbb4 100644
--- a/test/support/debug_mode_helper.h
+++ b/test/support/debug_mode_helper.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/deleter_types.h b/test/support/deleter_types.h
index ec7016801..1c99feaa6 100644
--- a/test/support/deleter_types.h
+++ b/test/support/deleter_types.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/demangle.h b/test/support/demangle.h
index 98d93c85a..f8e90a19f 100644
--- a/test/support/demangle.h
+++ b/test/support/demangle.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_DEMANGLE_H
diff --git a/test/support/disable_missing_braces_warning.h b/test/support/disable_missing_braces_warning.h
index ac8b40728..9e115f8bf 100644
--- a/test/support/disable_missing_braces_warning.h
+++ b/test/support/disable_missing_braces_warning.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_DISABLE_MISSING_BRACES_WARNING_H
diff --git a/test/support/experimental_any_helpers.h b/test/support/experimental_any_helpers.h
index f7bc0e33e..eeffd8c98 100644
--- a/test/support/experimental_any_helpers.h
+++ b/test/support/experimental_any_helpers.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef EXPERIMENTAL_ANY_HELPERS_H
diff --git a/test/support/external_threads.cpp b/test/support/external_threads.cpp
index 019ab473a..3ffce1a63 100644
--- a/test/support/external_threads.cpp
+++ b/test/support/external_threads.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #define _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL
diff --git a/test/support/hexfloat.h b/test/support/hexfloat.h
index 19008d1d5..23ad9a3f9 100644
--- a/test/support/hexfloat.h
+++ b/test/support/hexfloat.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/is_transparent.h b/test/support/is_transparent.h
index f7cdbbc14..667877526 100644
--- a/test/support/is_transparent.h
+++ b/test/support/is_transparent.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/min_allocator.h b/test/support/min_allocator.h
index 454749397..100e6d14a 100644
--- a/test/support/min_allocator.h
+++ b/test/support/min_allocator.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/msvc_stdlib_force_include.hpp b/test/support/msvc_stdlib_force_include.hpp
index f2ec35fd0..c3dd3aad9 100644
--- a/test/support/msvc_stdlib_force_include.hpp
+++ b/test/support/msvc_stdlib_force_include.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/nasty_containers.hpp b/test/support/nasty_containers.hpp
index b52263a97..91251666b 100644
--- a/test/support/nasty_containers.hpp
+++ b/test/support/nasty_containers.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/nasty_macros.hpp b/test/support/nasty_macros.hpp
index 3c2a5e27a..7bc3f1e6a 100644
--- a/test/support/nasty_macros.hpp
+++ b/test/support/nasty_macros.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_NASTY_MACROS_HPP
diff --git a/test/support/nothing_to_do.pass.cpp b/test/support/nothing_to_do.pass.cpp
index 9125fe194..1b2313324 100644
--- a/test/support/nothing_to_do.pass.cpp
+++ b/test/support/nothing_to_do.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/platform_support.h b/test/support/platform_support.h
index eae79541d..19531ce08 100644
--- a/test/support/platform_support.h
+++ b/test/support/platform_support.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/poisoned_hash_helper.hpp b/test/support/poisoned_hash_helper.hpp
index 07cb72692..83687ddf6 100644
--- a/test/support/poisoned_hash_helper.hpp
+++ b/test/support/poisoned_hash_helper.hpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_POISONED_HASH_HELPER_HPP
diff --git a/test/support/private_constructor.hpp b/test/support/private_constructor.hpp
index a9fcf6897..69411a8d9 100644
--- a/test/support/private_constructor.hpp
+++ b/test/support/private_constructor.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/set_windows_crt_report_mode.h b/test/support/set_windows_crt_report_mode.h
index 5fc1698b4..206bd5ddb 100644
--- a/test/support/set_windows_crt_report_mode.h
+++ b/test/support/set_windows_crt_report_mode.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_SET_WINDOWS_CRT_REPORT_MODE_H
diff --git a/test/support/test.support/test_convertible_header.pass.cpp b/test/support/test.support/test_convertible_header.pass.cpp
index a56b84b47..0158dfe62 100644
--- a/test/support/test.support/test_convertible_header.pass.cpp
+++ b/test/support/test.support/test_convertible_header.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test.support/test_demangle.pass.cpp b/test/support/test.support/test_demangle.pass.cpp
index 08808c194..5c62ecbb1 100644
--- a/test/support/test.support/test_demangle.pass.cpp
+++ b/test/support/test.support/test_demangle.pass.cpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "demangle.h"
diff --git a/test/support/test.support/test_macros_header_exceptions.fail.cpp b/test/support/test.support/test_macros_header_exceptions.fail.cpp
index ade2cd98f..66a01c967 100644
--- a/test/support/test.support/test_macros_header_exceptions.fail.cpp
+++ b/test/support/test.support/test_macros_header_exceptions.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test.support/test_macros_header_exceptions.pass.cpp b/test/support/test.support/test_macros_header_exceptions.pass.cpp
index 589e148a0..274cad82e 100644
--- a/test/support/test.support/test_macros_header_exceptions.pass.cpp
+++ b/test/support/test.support/test_macros_header_exceptions.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test.support/test_macros_header_rtti.fail.cpp b/test/support/test.support/test_macros_header_rtti.fail.cpp
index 851a6c601..4096ce43f 100644
--- a/test/support/test.support/test_macros_header_rtti.fail.cpp
+++ b/test/support/test.support/test_macros_header_rtti.fail.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test.support/test_macros_header_rtti.pass.cpp b/test/support/test.support/test_macros_header_rtti.pass.cpp
index dee1a0494..946157993 100644
--- a/test/support/test.support/test_macros_header_rtti.pass.cpp
+++ b/test/support/test.support/test_macros_header_rtti.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test.support/test_poisoned_hash_helper.pass.cpp b/test/support/test.support/test_poisoned_hash_helper.pass.cpp
index 4dffae6db..f94f96368 100644
--- a/test/support/test.support/test_poisoned_hash_helper.pass.cpp
+++ b/test/support/test.support/test_poisoned_hash_helper.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp b/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
index 669f175c4..40e50c14e 100644
--- a/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
+++ b/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp b/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
index 856574dbc..27f1fb640 100644
--- a/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
+++ b/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test_allocator.h b/test/support/test_allocator.h
index 60f9a21b2..1d6acf576 100644
--- a/test/support/test_allocator.h
+++ b/test/support/test_allocator.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test_comparisons.h b/test/support/test_comparisons.h
index cf094eb65..96a75039f 100644
--- a/test/support/test_comparisons.h
+++ b/test/support/test_comparisons.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //  A set of routines for testing the comparison operators of a type
diff --git a/test/support/test_convertible.hpp b/test/support/test_convertible.hpp
index e0d42f74a..322ef506d 100644
--- a/test/support/test_convertible.hpp
+++ b/test/support/test_convertible.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test_iterators.h b/test/support/test_iterators.h
index 0fdb225b2..a54787af1 100644
--- a/test/support/test_iterators.h
+++ b/test/support/test_iterators.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index e45253534..8e809bfc3 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===---------------------------- test_macros.h ---------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test_memory_resource.hpp b/test/support/test_memory_resource.hpp
index 4b8167ba0..0483f3ba6 100644
--- a/test/support/test_memory_resource.hpp
+++ b/test/support/test_memory_resource.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/test_workarounds.h b/test/support/test_workarounds.h
index e88a14957..14ec96861 100644
--- a/test/support/test_workarounds.h
+++ b/test/support/test_workarounds.h
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/tracked_value.h b/test/support/tracked_value.h
index 6b75516e6..01b8c840d 100644
--- a/test/support/tracked_value.h
+++ b/test/support/tracked_value.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_TRACKED_VALUE_H
diff --git a/test/support/truncate_fp.h b/test/support/truncate_fp.h
index 83b2b2cff..1ac959ec4 100644
--- a/test/support/truncate_fp.h
+++ b/test/support/truncate_fp.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/type_id.h b/test/support/type_id.h
index 046336538..6131d27c9 100644
--- a/test/support/type_id.h
+++ b/test/support/type_id.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_TYPE_ID_H
diff --git a/test/support/unique_ptr_test_helper.h b/test/support/unique_ptr_test_helper.h
index 18c8f780b..5f56f7123 100644
--- a/test/support/unique_ptr_test_helper.h
+++ b/test/support/unique_ptr_test_helper.h
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/user_defined_integral.hpp b/test/support/user_defined_integral.hpp
index 383b65f72..a313fe6de 100644
--- a/test/support/user_defined_integral.hpp
+++ b/test/support/user_defined_integral.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_USER_DEFINED_INTEGRAL_HPP
diff --git a/test/support/uses_alloc_types.hpp b/test/support/uses_alloc_types.hpp
index 426d2583e..4b1a95d53 100644
--- a/test/support/uses_alloc_types.hpp
+++ b/test/support/uses_alloc_types.hpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/support/variant_test_helpers.hpp b/test/support/variant_test_helpers.hpp
index 759815464..59988b5f4 100644
--- a/test/support/variant_test_helpers.hpp
+++ b/test/support/variant_test_helpers.hpp
@@ -1,10 +1,9 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_VARIANT_TEST_HELPERS_HPP
diff --git a/utils/cat_files.py b/utils/cat_files.py
index 83e7632f3..ac4f38696 100755
--- a/utils/cat_files.py
+++ b/utils/cat_files.py
@@ -1,10 +1,9 @@
 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/gen_link_script.py b/utils/gen_link_script.py
index 24fe5ce99..79583e567 100755
--- a/utils/gen_link_script.py
+++ b/utils/gen_link_script.py
@@ -1,10 +1,9 @@
 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/__init__.py b/utils/libcxx/__init__.py
index 7523a3d8b..d2e99bae3 100644
--- a/utils/libcxx/__init__.py
+++ b/utils/libcxx/__init__.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/compiler.py b/utils/libcxx/compiler.py
index 70022d7a4..a553dbf60 100644
--- a/utils/libcxx/compiler.py
+++ b/utils/libcxx/compiler.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/sym_check/__init__.py b/utils/libcxx/sym_check/__init__.py
index 1aa2b450c..0766df2ea 100644
--- a/utils/libcxx/sym_check/__init__.py
+++ b/utils/libcxx/sym_check/__init__.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/sym_check/diff.py b/utils/libcxx/sym_check/diff.py
index 0821ef6f7..fdd77a9d4 100644
--- a/utils/libcxx/sym_check/diff.py
+++ b/utils/libcxx/sym_check/diff.py
@@ -1,10 +1,9 @@
 # -*- Python -*- vim: set syntax=python tabstop=4 expandtab cc=80:
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 """
diff --git a/utils/libcxx/sym_check/extract.py b/utils/libcxx/sym_check/extract.py
index 152ff97db..1012c6b11 100644
--- a/utils/libcxx/sym_check/extract.py
+++ b/utils/libcxx/sym_check/extract.py
@@ -1,10 +1,9 @@
 # -*- Python -*- vim: set syntax=python tabstop=4 expandtab cc=80:
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 """
diff --git a/utils/libcxx/sym_check/match.py b/utils/libcxx/sym_check/match.py
index fae400e4e..636e3ab6e 100644
--- a/utils/libcxx/sym_check/match.py
+++ b/utils/libcxx/sym_check/match.py
@@ -1,10 +1,9 @@
 # -*- Python -*- vim: set syntax=python tabstop=4 expandtab cc=80:
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 """
diff --git a/utils/libcxx/sym_check/util.py b/utils/libcxx/sym_check/util.py
index 8a4c4ab49..c6f7e90f3 100644
--- a/utils/libcxx/sym_check/util.py
+++ b/utils/libcxx/sym_check/util.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index 1aa52ddbb..aba1ada90 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/test/executor.py b/utils/libcxx/test/executor.py
index 0ccf96caa..607c9384b 100644
--- a/utils/libcxx/test/executor.py
+++ b/utils/libcxx/test/executor.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/test/format.py b/utils/libcxx/test/format.py
index 6a334ac31..a8dae4898 100644
--- a/utils/libcxx/test/format.py
+++ b/utils/libcxx/test/format.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/test/target_info.py b/utils/libcxx/test/target_info.py
index 32bbb2e11..fb450805f 100644
--- a/utils/libcxx/test/target_info.py
+++ b/utils/libcxx/test/target_info.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===//
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===//
 
diff --git a/utils/libcxx/test/tracing.py b/utils/libcxx/test/tracing.py
index c590ba3ef..9ef9ae350 100644
--- a/utils/libcxx/test/tracing.py
+++ b/utils/libcxx/test/tracing.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/libcxx/util.py b/utils/libcxx/util.py
index ecfb9afb7..46c09bf66 100644
--- a/utils/libcxx/util.py
+++ b/utils/libcxx/util.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/merge_archives.py b/utils/merge_archives.py
index 58d92f0e2..a307494d8 100755
--- a/utils/merge_archives.py
+++ b/utils/merge_archives.py
@@ -1,10 +1,9 @@
 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/not.py b/utils/not.py
index d9ceb8515..2ebf5088d 100644
--- a/utils/not.py
+++ b/utils/not.py
@@ -1,9 +1,8 @@
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
diff --git a/utils/sym_diff.py b/utils/sym_diff.py
index c01f71c92..6bd1b57e0 100755
--- a/utils/sym_diff.py
+++ b/utils/sym_diff.py
@@ -1,10 +1,9 @@
 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 """
diff --git a/utils/sym_extract.py b/utils/sym_extract.py
index 0d9d2eeb8..156e8830e 100755
--- a/utils/sym_extract.py
+++ b/utils/sym_extract.py
@@ -1,10 +1,9 @@
 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 """
diff --git a/utils/sym_match.py b/utils/sym_match.py
index 48582ce66..1fd39ca5f 100755
--- a/utils/sym_match.py
+++ b/utils/sym_match.py
@@ -1,10 +1,9 @@
 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
-#                     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.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
-- 
GitLab


From 9daab637c186e2033e733edf5587125528c00cc6 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Sat, 19 Jan 2019 11:38:40 +0000
Subject: [PATCH 059/137] Update generator script to use the new license file
 header.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351650 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../generate_feature_test_macro_components.py              | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
index d019d8fe5..00b63d5eb 100755
--- a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
+++ b/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
@@ -828,10 +828,9 @@ def produce_tests():
     test_body = \
 """//===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-- 
GitLab


From 87d470c6f6d6bbe091716812adddc719873ccf29 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Sat, 19 Jan 2019 11:54:04 +0000
Subject: [PATCH 060/137] Update an example to use the new LLVM file header.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351653 91177308-0d34-0410-b5e6-96231b3b80d8
---
 docs/DesignDocs/CapturingConfigInfo.rst | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/docs/DesignDocs/CapturingConfigInfo.rst b/docs/DesignDocs/CapturingConfigInfo.rst
index 29156bff8..8f2d0cd2d 100644
--- a/docs/DesignDocs/CapturingConfigInfo.rst
+++ b/docs/DesignDocs/CapturingConfigInfo.rst
@@ -56,10 +56,9 @@ configuration all together. An example "__config" header generated when
 
   //===----------------------------------------------------------------------===//
   //
-  //                     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.
+  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+  // See https://llvm.org/LICENSE.txt for license information.
+  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   //
   //===----------------------------------------------------------------------===//
 
@@ -77,10 +76,9 @@ configuration all together. An example "__config" header generated when
   // -*- C++ -*-
   //===--------------------------- __config ---------------------------------===//
   //
-  //                     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.
+  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+  // See https://llvm.org/LICENSE.txt for license information.
+  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   //
   //===----------------------------------------------------------------------===//
 
-- 
GitLab


From e09ce3f4e1be4fcbba85418f53a54c35c93f25fb Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sat, 19 Jan 2019 23:36:06 +0000
Subject: [PATCH 061/137] Improve docker images and configuration; create
 compiler-zoo image

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351667 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/docker/build_docker_image.sh            | 108 ----------
 utils/docker/debian9/Dockerfile               | 186 +++++++++++++-----
 utils/docker/docker-compose.yml               |  14 ++
 utils/docker/scripts/build_gcc.sh             |  90 ---------
 utils/docker/scripts/build_gcc_version.sh     | 109 ++++++++++
 utils/docker/scripts/build_install_llvm.sh    | 113 -----------
 utils/docker/scripts/build_llvm_version.sh    | 107 ++++++++++
 .../docker/scripts/install_clang_packages.sh  |  24 ++-
 utils/docker/scripts/run_buildbot.sh          |   9 +-
 9 files changed, 395 insertions(+), 365 deletions(-)
 delete mode 100755 utils/docker/build_docker_image.sh
 create mode 100644 utils/docker/docker-compose.yml
 delete mode 100755 utils/docker/scripts/build_gcc.sh
 create mode 100755 utils/docker/scripts/build_gcc_version.sh
 delete mode 100755 utils/docker/scripts/build_install_llvm.sh
 create mode 100755 utils/docker/scripts/build_llvm_version.sh

diff --git a/utils/docker/build_docker_image.sh b/utils/docker/build_docker_image.sh
deleted file mode 100755
index cc6a18870..000000000
--- a/utils/docker/build_docker_image.sh
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/bin/bash
-#===- libcxx/utils/docker/build_docker_image.sh ----------------------------===//
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===----------------------------------------------------------------------===//
-set -e
-
-IMAGE_SOURCE=""
-DOCKER_REPOSITORY=""
-DOCKER_TAG=""
-
-function show_usage() {
-  cat << EOF
-Usage: build_docker_image.sh [options] [-- [cmake_args]...]
-
-Available options:
-  General:
-    -h|--help               show this help message
-  Docker-specific:
-    -s|--source             image source dir (i.e. debian8, nvidia-cuda, etc)
-    -d|--docker-repository  docker repository for the image
-    -t|--docker-tag         docker tag for the image
-
-Required options: --source and --docker-repository.
-
-For example, running:
-$ build_docker_image.sh -s debian9 -d mydocker/debian9-clang -t latest
-will produce two docker images:
-    mydocker/debian9-clang-build:latest - an intermediate image used to compile
-      clang.
-    mydocker/clang-debian9:latest       - a small image with preinstalled clang.
-Please note that this example produces a not very useful installation, since it
-doesn't override CMake defaults, which produces a Debug and non-boostrapped
-version of clang.
-EOF
-}
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -h|--help)
-      show_usage
-      exit 0
-      ;;
-    -s|--source)
-      shift
-      IMAGE_SOURCE="$1"
-      shift
-      ;;
-    -d|--docker-repository)
-      shift
-      DOCKER_REPOSITORY="$1"
-      shift
-      ;;
-    -t|--docker-tag)
-      shift
-      DOCKER_TAG="$1"
-      shift
-      ;;
-    *)
-      echo "Unknown argument $1"
-      exit 1
-      ;;
-  esac
-done
-
-
-command -v docker >/dev/null ||
-  {
-    echo "Docker binary cannot be found. Please install Docker to use this script."
-    exit 1
-  }
-
-if [ "$IMAGE_SOURCE" == "" ]; then
-  echo "Required argument missing: --source"
-  exit 1
-fi
-
-if [ "$DOCKER_REPOSITORY" == "" ]; then
-  echo "Required argument missing: --docker-repository"
-  exit 1
-fi
-
-SOURCE_DIR=$(dirname $0)
-if [ ! -d "$SOURCE_DIR/$IMAGE_SOURCE" ]; then
-  echo "No sources for '$IMAGE_SOURCE' were found in $SOURCE_DIR"
-  exit 1
-fi
-
-BUILD_DIR=$(mktemp -d)
-trap "rm -rf $BUILD_DIR" EXIT
-echo "Using a temporary directory for the build: $BUILD_DIR"
-
-cp -r "$SOURCE_DIR/$IMAGE_SOURCE" "$BUILD_DIR/$IMAGE_SOURCE"
-cp -r "$SOURCE_DIR/scripts" "$BUILD_DIR/scripts"
-
-
-if [ "$DOCKER_TAG" != "" ]; then
-  DOCKER_TAG=":$DOCKER_TAG"
-fi
-
-echo "Building ${DOCKER_REPOSITORY}${DOCKER_TAG} from $IMAGE_SOURCE"
-docker build -t "${DOCKER_REPOSITORY}${DOCKER_TAG}" \
-  -f "$BUILD_DIR/$IMAGE_SOURCE/Dockerfile" \
-  "$BUILD_DIR"
-echo "Done"
diff --git a/utils/docker/debian9/Dockerfile b/utils/docker/debian9/Dockerfile
index 3f291d04c..f93670b48 100644
--- a/utils/docker/debian9/Dockerfile
+++ b/utils/docker/debian9/Dockerfile
@@ -1,13 +1,13 @@
-#===- libcxx/utils/docker/debian9/Dockerfile -------------------------===//
+#===- libcxx/utils/docker/debian9/Dockerfile --------------------------------------------------===//
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
-#===----------------------------------------------------------------------===//
+#===-------------------------------------------------------------------------------------------===//
 
 # Setup the base builder image with the packages we'll need to build GCC and Clang from source.
-FROM launcher.gcr.io/google/debian9:latest as builder-base
+FROM launcher.gcr.io/google/debian9:latest AS builder-base
 LABEL maintainer "libc++ Developers"
 
 RUN apt-get update && \
@@ -33,52 +33,127 @@ RUN apt-get update && \
       autoconf \
       binutils-dev \
       binutils-gold \
-      software-properties-common && \
+      software-properties-common \
+      gnupg \
+      apt-transport-https \
+      systemd \
+      sysvinit-utils && \
   update-alternatives --install "/usr/bin/ld" "ld" "/usr/bin/ld.gold" 20 && \
-  update-alternatives --install "/usr/bin/ld" "ld" "/usr/bin/ld.bfd" 10
+  update-alternatives --install "/usr/bin/ld" "ld" "/usr/bin/ld.bfd" 10 && \
+  rm -rf /var/lib/apt/lists/*
+
+
+# Build GCC versions
+FROM builder-base as gcc-48-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_gcc_version.sh /tmp/build_gcc_version.sh
+RUN /tmp/build_gcc_version.sh --install /opt/gcc-4.8.5 --branch gcc-4_8_5-release \
+    --cherry-pick ec1cc0263f156f70693a62cf17b254a0029f4852
 
-# Build GCC 4.9 for testing our C++11 against
 FROM builder-base as gcc-49-builder
 LABEL maintainer "libc++ Developers"
 
-ADD scripts/build_gcc.sh /tmp/build_gcc.sh
+ADD scripts/build_gcc_version.sh /tmp/build_gcc_version.sh
+RUN /tmp/build_gcc_version.sh --install /opt/gcc-4.9.4 --branch gcc-4_9_4-release
+
+FROM builder-base as gcc-5-builder
+LABEL maintainer "libc++ Developers"
 
-RUN git clone --depth=1 --branch gcc-4_9_4-release git://gcc.gnu.org/git/gcc.git /tmp/gcc-4.9.4
-RUN cd /tmp/gcc-4.9.4/ && ./contrib/download_prerequisites
-RUN /tmp/build_gcc.sh --source /tmp/gcc-4.9.4 --to /opt/gcc-4.9.4
+ADD scripts/build_gcc_version.sh /tmp/build_gcc_version.sh
+RUN /tmp/build_gcc_version.sh --install /opt/gcc-5 --branch gcc-5_5_0-release
+
+FROM builder-base as gcc-6-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_gcc_version.sh /tmp/build_gcc_version.sh
+RUN /tmp/build_gcc_version.sh --install /opt/gcc-6 --branch gcc-6_5_0-release
+
+FROM builder-base as gcc-7-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_gcc_version.sh /tmp/build_gcc_version.sh
+RUN /tmp/build_gcc_version.sh --install /opt/gcc-7 --branch gcc-7_4_0-release
+
+FROM builder-base as gcc-8-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_gcc_version.sh /tmp/build_gcc_version.sh
+RUN /tmp/build_gcc_version.sh --install /opt/gcc-8 --branch gcc-8_2_0-release
 
-# Build GCC ToT for testing in all dialects.
 FROM builder-base as gcc-tot-builder
 LABEL maintainer "libc++ Developers"
 
-ADD scripts/build_gcc.sh /tmp/build_gcc.sh
+ADD scripts/build_gcc_version.sh /tmp/build_gcc_version.sh
+RUN /tmp/build_gcc_version.sh --install /opt/gcc-tot --branch master
+
+# Build additional LLVM versions
+FROM builder-base as llvm-36-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-3.6 --branch release/3.6.x
+
+FROM builder-base as llvm-37-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-3.7 --branch release/3.7.x
+
+FROM builder-base as llvm-38-builder
+LABEL maintainer "libc++ Developers"
 
-RUN git clone --depth=1 git://gcc.gnu.org/git/gcc.git /tmp/gcc-tot
-RUN cd /tmp/gcc-tot && ./contrib/download_prerequisites
-RUN /tmp/build_gcc.sh --source /tmp/gcc-tot --to /opt/gcc-tot
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-3.8 --branch release/3.8.x
+
+FROM builder-base as llvm-39-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-3.9 --branch release/3.9.x
 
-# Build LLVM 4.0 which is used to test against a "legacy" compiler.
 FROM builder-base as llvm-4-builder
 LABEL maintainer "libc++ Developers"
 
-ADD scripts/checkout_git.sh /tmp/checkout_git.sh
-ADD scripts/build_install_llvm.sh /tmp/build_install_llvm.sh
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-4.0 --branch release/4.x
+
+FROM builder-base as llvm-5-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-5.0 --branch release/5.x
+
+FROM builder-base as llvm-6-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-6.0 --branch release/6.x
+
+FROM builder-base as llvm-7-builder
+LABEL maintainer "libc++ Developers"
 
-RUN /tmp/checkout_git.sh --to /tmp/llvm-4.0 -p clang -p compiler-rt --branch release_40
-RUN /tmp/build_install_llvm.sh \
-    --install /opt/llvm-4.0 \
-    --source /tmp/llvm-4.0 \
-    --build /tmp/build-llvm-4.0 \
-    -i install-clang -i install-clang-headers \
-    -i install-compiler-rt \
-    -- \
-    -DCMAKE_BUILD_TYPE=RELEASE \
-    -DLLVM_ENABLE_ASSERTIONS=ON
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-7.0 --branch release/7.x
 
-# Stage 2. Produce a minimal release image with build results.
-FROM launcher.gcr.io/google/debian9:latest
+FROM builder-base as llvm-8-builder
 LABEL maintainer "libc++ Developers"
 
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-8.0 --branch release/8.x
+
+FROM builder-base as llvm-tot-builder
+LABEL maintainer "libc++ Developers"
+
+ADD scripts/build_llvm_version.sh /tmp/build_llvm_version.sh
+RUN /tmp/build_llvm_version.sh --install /opt/llvm-tot --branch master
+
+
+#===-------------------------------------------------------------------------------------------===//
+# buildslave
+#===-------------------------------------------------------------------------------------------===//
+FROM builder-base AS buildbot
+
 # Copy over the GCC and Clang installations
 COPY --from=gcc-49-builder /opt/gcc-4.9.4 /opt/gcc-4.9.4
 COPY --from=gcc-tot-builder /opt/gcc-tot /opt/gcc-tot
@@ -88,27 +163,40 @@ RUN ln -s /opt/gcc-4.9.4/bin/gcc /usr/local/bin/gcc-4.9 && \
     ln -s /opt/gcc-4.9.4/bin/g++ /usr/local/bin/g++-4.9
 
 RUN apt-get update && \
-    apt-get install -y \
-      ca-certificates \
-      gnupg \
-      build-essential \
-      apt-transport-https \
-      curl \
-      software-properties-common
-
-RUN apt-get install -y --no-install-recommends \
-    systemd \
-    sysvinit-utils \
-    cmake \
-    subversion \
-    git \
-    ninja-build \
-    gcc-multilib \
-    g++-multilib \
-    python \
-    buildbot-slave
+    apt-get install -y --no-install-recommends \
+    bash-completion \
+    buildbot-slave \
+  && rm -rf /var/lib/apt/lists/*
 
 ADD scripts/install_clang_packages.sh /tmp/install_clang_packages.sh
 RUN /tmp/install_clang_packages.sh && rm /tmp/install_clang_packages.sh
 
 RUN git clone https://git.llvm.org/git/libcxx.git /libcxx
+
+#===-------------------------------------------------------------------------------------------===//
+#  compiler-zoo
+#===-------------------------------------------------------------------------------------------===//
+FROM  buildbot AS compiler-zoo
+LABEL maintainer "libc++ Developers"
+
+# Copy over the GCC and Clang installations
+COPY --from=gcc-48-builder /opt/gcc-4.8.5 /opt/gcc-4.8.5
+COPY --from=gcc-49-builder /opt/gcc-4.9.4 /opt/gcc-4.9.4
+COPY --from=gcc-5-builder /opt/gcc-5   /opt/gcc-5
+COPY --from=gcc-6-builder /opt/gcc-6   /opt/gcc-6
+COPY --from=gcc-7-builder /opt/gcc-7   /opt/gcc-7
+COPY --from=gcc-8-builder /opt/gcc-8   /opt/gcc-8
+COPY --from=gcc-tot-builder /opt/gcc-tot /opt/gcc-tot
+
+COPY --from=llvm-36-builder /opt/llvm-3.6 /opt/llvm-3.6
+COPY --from=llvm-37-builder /opt/llvm-3.7 /opt/llvm-3.7
+COPY --from=llvm-38-builder /opt/llvm-3.8 /opt/llvm-3.8
+COPY --from=llvm-39-builder /opt/llvm-3.9 /opt/llvm-3.9
+COPY --from=llvm-4-builder /opt/llvm-4.0 /opt/llvm-4.0
+COPY --from=llvm-5-builder /opt/llvm-5.0 /opt/llvm-5.0
+COPY --from=llvm-6-builder /opt/llvm-6.0 /opt/llvm-6.0
+COPY --from=llvm-7-builder /opt/llvm-7.0 /opt/llvm-7.0
+COPY --from=llvm-8-builder /opt/llvm-8.0 /opt/llvm-8.0
+COPY --from=llvm-tot-builder /opt/llvm-tot /opt/llvm-tot
+
+
diff --git a/utils/docker/docker-compose.yml b/utils/docker/docker-compose.yml
new file mode 100644
index 000000000..5e8e5a4a7
--- /dev/null
+++ b/utils/docker/docker-compose.yml
@@ -0,0 +1,14 @@
+version: '3.4'
+services:
+  buildbot:
+    build:
+      context: .
+      dockerfile: debian9/Dockerfile
+      target: buildbot
+    image: ericwf/libcxx-buildbot-base:latest
+  compiler-zoo:
+    build:
+      context: .
+      dockerfile: debian9/Dockerfile
+      target: compiler-zoo
+    image: ericwf/compiler-zoo:latest
diff --git a/utils/docker/scripts/build_gcc.sh b/utils/docker/scripts/build_gcc.sh
deleted file mode 100755
index 3627a9ae9..000000000
--- a/utils/docker/scripts/build_gcc.sh
+++ /dev/null
@@ -1,90 +0,0 @@
-#!/usr/bin/env bash
-#===- libcxx/utils/docker/scripts/build-gcc.sh ----------------------------===//
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===-----------------------------------------------------------------------===//
-
-set -e
-
-
-function show_usage() {
-  cat << EOF
-Usage: build-gcc.sh [options]
-
-Run autoconf with the specified arguments. Used inside docker container.
-
-Available options:
-  -h|--help           show this help message
-  --source            the source path from which to run the configuration.
-  --to                destination directory where to install the targets.
-Required options: --to, at least one --install-target.
-
-All options after '--' are passed to CMake invocation.
-EOF
-}
-
-GCC_INSTALL_DIR=""
-GCC_SOURCE_DIR=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --to)
-      shift
-      GCC_INSTALL_DIR="$1"
-      shift
-      ;;
-    --source)
-      shift
-      GCC_SOURCE_DIR="$1"
-      shift
-      ;;
-    -h|--help)
-      show_usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-  esac
-done
-
-if [ "$GCC_INSTALL_DIR" == "" ]; then
-  echo "No install directory. Please specify the --to argument."
-  exit 1
-fi
-
-if [ "$GCC_SOURCE_DIR" == "" ]; then
-  echo "No source directory. Please specify the --source argument."
-  exit 1
-fi
-
-GCC_NAME=`basename $GCC_SOURCE_DIR`
-GCC_BUILD_DIR="/tmp/gcc-build-root/build-$GCC_NAME"
-
-mkdir -p "$GCC_INSTALL_DIR"
-mkdir -p "$GCC_BUILD_DIR"
-pushd "$GCC_BUILD_DIR"
-
-# Run the build as specified in the build arguments.
-echo "Running configuration"
-$GCC_SOURCE_DIR/configure --prefix=$GCC_INSTALL_DIR \
-  --disable-bootstrap --disable-libgomp --disable-libitm \
-  --disable-libvtv --disable-libcilkrts --disable-libmpx \
-  --disable-liboffloadmic --disable-libcc1 --enable-languages=c,c++
-
-NPROC=`nproc`
-echo "Running build with $NPROC threads"
-make -j$NPROC
-
-echo "Installing to $GCC_INSTALL_DIR"
-make install -j$NPROC
-
-popd
-
-# Cleanup.
-rm -rf "$GCC_BUILD_DIR"
-
-echo "Done"
\ No newline at end of file
diff --git a/utils/docker/scripts/build_gcc_version.sh b/utils/docker/scripts/build_gcc_version.sh
new file mode 100755
index 000000000..f569d7e18
--- /dev/null
+++ b/utils/docker/scripts/build_gcc_version.sh
@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+#===- libcxx/utils/docker/scripts/build-gcc.sh ----------------------------===//
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===-----------------------------------------------------------------------===//
+
+set -e
+
+function show_usage() {
+  cat << EOF
+Usage: build_gcc_version.sh [options]
+
+Run autoconf with the specified arguments. Used inside docker container.
+
+Available options:
+  -h|--help           show this help message
+  --branch            the branch of gcc you want to build.
+  --cherry-pick       a commit hash to apply to the GCC sources.
+  --install           destination directory where to install the targets.
+Required options: --install and --branch
+
+All options after '--' are passed to CMake invocation.
+EOF
+}
+
+GCC_INSTALL_DIR=""
+GCC_BRANCH=""
+CHERRY_PICK=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --install)
+      shift
+      GCC_INSTALL_DIR="$1"
+      shift
+      ;;
+    --branch)
+      shift
+      GCC_BRANCH="$1"
+      shift
+      ;;
+    --cherry-pick)
+      shift
+      CHERRY_PICK="$1"
+      shift
+      ;;
+    -h|--help)
+      show_usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+  esac
+done
+
+if [ "$GCC_INSTALL_DIR" == "" ]; then
+  echo "No install directory. Please specify the --install argument."
+  exit 1
+fi
+
+if [ "$GCC_BRANCH" == "" ]; then
+  echo "No branch specified. Please specify the --branch argument."
+  exit 1
+fi
+
+set -x
+
+NPROC=`nproc`
+TMP_ROOT="$(mktemp -d -p /tmp)"
+GCC_SOURCE_DIR="$TMP_ROOT/gcc"
+GCC_BUILD_DIR="$TMP_ROOT/build"
+
+echo "Cloning source directory for branch $GCC_BRANCH"
+git clone --branch "$GCC_BRANCH" --single-branch --depth=1 git://gcc.gnu.org/git/gcc.git $GCC_SOURCE_DIR
+
+pushd "$GCC_SOURCE_DIR"
+if [ "$CHERRY_PICK" != "" ]; then
+  git fetch origin trunk --unshallow # Urg, we have to get the entire history. This will take a while.
+  git cherry-pick --no-commit -X theirs "$CHERRY_PICK"
+fi
+./contrib/download_prerequisites
+popd
+
+
+mkdir "$GCC_BUILD_DIR"
+pushd "$GCC_BUILD_DIR"
+
+# Run the build as specified in the build arguments.
+echo "Running configuration"
+$GCC_SOURCE_DIR/configure --prefix=$GCC_INSTALL_DIR \
+  --disable-bootstrap --disable-libgomp --disable-libitm \
+  --disable-libvtv --disable-libcilkrts --disable-libmpx \
+  --disable-liboffloadmic --disable-libcc1 --enable-languages=c,c++
+
+echo "Running build with $NPROC threads"
+make -j$NPROC
+echo "Installing to $GCC_INSTALL_DIR"
+make install -j$NPROC
+popd
+
+# Cleanup.
+rm -rf "$TMP_ROOT"
+
+echo "Done"
\ No newline at end of file
diff --git a/utils/docker/scripts/build_install_llvm.sh b/utils/docker/scripts/build_install_llvm.sh
deleted file mode 100755
index d37e52d32..000000000
--- a/utils/docker/scripts/build_install_llvm.sh
+++ /dev/null
@@ -1,113 +0,0 @@
-#!/usr/bin/env bash
-#===- llvm/utils/docker/scripts/build_install_llvm.sh ---------------------===//
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===-----------------------------------------------------------------------===//
-
-set -e
-
-function show_usage() {
-  cat << EOF
-Usage: build_install_llvm.sh [options] -- [cmake-args]
-
-Run cmake with the specified arguments. Used inside docker container.
-Passes additional -DCMAKE_INSTALL_PREFIX and puts the build results into
-the directory specified by --to option.
-
-Available options:
-  -h|--help           show this help message
-  -i|--install-target name of a cmake install target to build and include in
-                      the resulting archive. Can be specified multiple times.
-  --install           destination directory where to install the targets.
-  --source            location of the source tree.
-  --build             location to use as the build directory.
-Required options: --to, --source, --build, and at least one --install-target.
-
-All options after '--' are passed to CMake invocation.
-EOF
-}
-
-CMAKE_ARGS=""
-CMAKE_INSTALL_TARGETS=""
-CLANG_INSTALL_DIR=""
-CLANG_SOURCE_DIR=""
-CLANG_BUILD_DIR=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -i|--install-target)
-      shift
-      CMAKE_INSTALL_TARGETS="$CMAKE_INSTALL_TARGETS $1"
-      shift
-      ;;
-    --source)
-      shift
-      CLANG_SOURCE_DIR="$1"
-      shift
-      ;;
-    --build)
-      shift
-      CLANG_BUILD_DIR="$1"
-      shift
-      ;;
-    --install)
-      shift
-      CLANG_INSTALL_DIR="$1"
-      shift
-      ;;
-    --)
-      shift
-      CMAKE_ARGS="$*"
-      shift $#
-      ;;
-    -h|--help)
-      show_usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-  esac
-done
-
-if [ "$CLANG_SOURCE_DIR" == "" ]; then
-  echo "No source directory. Please pass --source."
-  exit 1
-fi
-
-if [ "$CLANG_BUILD_DIR" == "" ]; then
-  echo "No build directory. Please pass --build"
-  exit 1
-fi
-
-if [ "$CMAKE_INSTALL_TARGETS" == "" ]; then
-  echo "No install targets. Please pass one or more --install-target."
-  exit 1
-fi
-
-if [ "$CLANG_INSTALL_DIR" == "" ]; then
-  echo "No install directory. Please specify the --to argument."
-  exit 1
-fi
-
-echo "Building in $CLANG_BUILD_DIR"
-mkdir -p "$CLANG_BUILD_DIR"
-pushd "$CLANG_BUILD_DIR"
-
-# Run the build as specified in the build arguments.
-echo "Running build"
-cmake -GNinja \
-  -DCMAKE_INSTALL_PREFIX="$CLANG_INSTALL_DIR" \
-  $CMAKE_ARGS \
-  "$CLANG_SOURCE_DIR"
-ninja $CMAKE_INSTALL_TARGETS
-
-popd
-
-# Cleanup.
-rm -rf "$CLANG_BUILD_DIR"
-
-echo "Done"
diff --git a/utils/docker/scripts/build_llvm_version.sh b/utils/docker/scripts/build_llvm_version.sh
new file mode 100755
index 000000000..eb093c426
--- /dev/null
+++ b/utils/docker/scripts/build_llvm_version.sh
@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+#===- libcxx/utils/docker/scripts/build_install_llvm_version_default.sh -----------------------===//
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===-------------------------------------------------------------------------------------------===//
+
+set -e
+
+function show_usage() {
+  cat << EOF
+Usage: build_install_llvm.sh [options] -- [cmake-args]
+
+Run cmake with the specified arguments. Used inside docker container.
+Passes additional -DCMAKE_INSTALL_PREFIX and puts the build results into
+the directory specified by --to option.
+
+Available options:
+  -h|--help           show this help message
+  --install           destination directory where to install the targets.
+  --branch            the branch or tag of LLVM to build
+Required options: --install, and --version.
+
+All options after '--' are passed to CMake invocation.
+EOF
+}
+
+LLVM_BRANCH=""
+CMAKE_ARGS=""
+LLVM_INSTALL_DIR=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --install)
+      shift
+      LLVM_INSTALL_DIR="$1"
+      shift
+      ;;
+    --branch)
+      shift
+      LLVM_BRANCH="$1"
+      shift
+      ;;
+    --)
+      shift
+      CMAKE_ARGS="$*"
+      shift $#
+      ;;
+    -h|--help)
+      show_usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+  esac
+done
+
+
+if [ "$LLVM_INSTALL_DIR" == "" ]; then
+  echo "No install directory. Please specify the --install argument."
+  exit 1
+fi
+
+if [ "$LLVM_BRANCH" == "" ]; then
+  echo "No install directory. Please specify the --branch argument."
+  exit 1
+fi
+
+if [ "$CMAKE_ARGS" == "" ]; then
+  CMAKE_ARGS="-DCMAKE_BUILD_TYPE=RELEASE '-DCMAKE_C_FLAGS=-gline-tables-only' '-DCMAKE_CXX_FLAGS=-gline-tables-only' -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_INSTALL_TOOLCHAIN_ONLY=ON"
+fi
+
+set -x
+
+TMP_ROOT="$(mktemp -d -p /tmp)"
+LLVM_SOURCE_DIR="$TMP_ROOT/llvm-project"
+LLVM_BUILD_DIR="$TMP_ROOT/build"
+LLVM="$LLVM_SOURCE_DIR/llvm"
+
+git clone --branch $LLVM_BRANCH --single-branch --depth=1 https://github.com/llvm/llvm-project.git $LLVM_SOURCE_DIR
+
+pushd "$LLVM_SOURCE_DIR"
+
+# Setup the source-tree using the old style layout
+ln -s $LLVM_SOURCE_DIR/libcxx $LLVM/projects/libcxx
+ln -s $LLVM_SOURCE_DIR/libcxxabi $LLVM/projects/libcxxabi
+ln -s $LLVM_SOURCE_DIR/compiler-rt $LLVM/projects/compiler-rt
+ln -s $LLVM_SOURCE_DIR/clang $LLVM/tools/clang
+ln -s $LLVM_SOURCE_DIR/clang-tools-extra $LLVM/tools/clang/tools/extra
+
+popd
+
+# Configure and build
+mkdir "$LLVM_BUILD_DIR"
+pushd "$LLVM_BUILD_DIR"
+cmake -GNinja "-DCMAKE_INSTALL_PREFIX=$LLVM_INSTALL_DIR" $CMAKE_ARGS $LLVM
+ninja install
+popd
+
+# Cleanup
+rm -rf "$TMP_ROOT/"
+
+echo "Done"
diff --git a/utils/docker/scripts/install_clang_packages.sh b/utils/docker/scripts/install_clang_packages.sh
index 4a46c90a4..94c98d6ad 100755
--- a/utils/docker/scripts/install_clang_packages.sh
+++ b/utils/docker/scripts/install_clang_packages.sh
@@ -20,7 +20,7 @@ Available options:
 EOF
 }
 
-VERSION=""
+VERSION="9"
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
@@ -39,12 +39,29 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-
+set -x
 
 curl -fsSL https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
 add-apt-repository -s "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs) main"
 apt-get update
-apt-get install -y --no-install-recommends clang
+apt-get upgrade -y
+apt-get install -y --no-install-recommends "clang-$VERSION"
+
+# FIXME(EricWF): Remove this once the clang packages are no longer broken.
+if [ -f "/usr/local/bin/clang" ]; then
+  echo "clang already exists"
+  exit 1
+else
+  CC_BINARY="$(which clang-$VERSION)"
+  ln -s "$CC_BINARY" "/usr/local/bin/clang"
+fi
+if [ -f "/usr/local/bin/clang++" ]; then
+  echo "clang++ already exists"
+  exit 1
+else
+  CXX_BINARY="$(which clang++-$VERSION)"
+  ln -s "$CXX_BINARY" "/usr/local/bin/clang++"
+fi
 
 echo "Testing clang version..."
 clang --version
@@ -58,6 +75,7 @@ if [ "$VERSION" == "" ]; then
   echo "Installing version '$VERSION'"
 fi
 
+apt-get purge -y "libc++-$VERSION-dev" "libc++abi-$VERSION-dev"
 apt-get install -y --no-install-recommends "libc++-$VERSION-dev" "libc++abi-$VERSION-dev"
 
 echo "Done"
diff --git a/utils/docker/scripts/run_buildbot.sh b/utils/docker/scripts/run_buildbot.sh
index 96e832dd4..c135fc4af 100755
--- a/utils/docker/scripts/run_buildbot.sh
+++ b/utils/docker/scripts/run_buildbot.sh
@@ -5,9 +5,14 @@ BOT_DIR=/b
 BOT_NAME=$1
 BOT_PASS=$2
 
-mkdir -p $BOT_DIR
+pushd /tmp
+curl -sSO https://dl.google.com/cloudagents/install-monitoring-agent.sh
+bash install-monitoring-agent.sh
+curl -sSO https://dl.google.com/cloudagents/install-logging-agent.sh
+bash install-logging-agent.sh --structured
+popd
 
-#curl "https://repo.stackdriver.com/stack-install.sh" | bash -s -- --write-gcm
+mkdir -p $BOT_DIR
 
 apt-get update -y
 apt-get upgrade -y
-- 
GitLab


From d162d3fe472c04f5b5e99936f13d4c0348f7884f Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 20 Jan 2019 01:12:53 +0000
Subject: [PATCH 062/137] Revert "Fix aligned allocation availability XFAILs
 after D56445."

This reverts commit r351625.

That fix was incomplete. I'm reverting so I can commit a complete fix
in a single revision.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351669 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../new.delete.array/delete_align_val_t_replace.pass.cpp     | 5 ++---
 .../new.delete/new.delete.array/new_align_val_t.pass.cpp     | 5 ++---
 .../new.delete.array/new_align_val_t_nothrow.pass.cpp        | 5 ++---
 .../new_align_val_t_nothrow_replace.pass.cpp                 | 5 ++---
 .../new.delete.single/delete_align_val_t_replace.pass.cpp    | 5 ++---
 .../new.delete/new.delete.single/new_align_val_t.pass.cpp    | 5 ++---
 .../new.delete.single/new_align_val_t_nothrow.pass.cpp       | 5 ++---
 .../new_align_val_t_nothrow_replace.pass.cpp                 | 5 ++---
 8 files changed, 16 insertions(+), 24 deletions(-)

diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
index 8500577f9..acbd2ee94 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
@@ -16,10 +16,9 @@
 // None of the current GCC compilers support this.
 // UNSUPPORTED: gcc-5, gcc-6
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
index abea113a6..7495efb6b 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
@@ -14,10 +14,9 @@
 // FIXME change this to XFAIL.
 // UNSUPPORTED: no-aligned-allocation && !gcc
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
index c47001f54..e324b9382 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
@@ -14,10 +14,9 @@
 // FIXME turn this into an XFAIL
 // UNSUPPORTED: no-aligned-allocation && !gcc
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
index 4be67f0f9..cdbf50263 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
@@ -9,10 +9,9 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
index 6c5cfcdd1..2ac87e3ab 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
@@ -15,10 +15,9 @@
 // None of the current GCC compilers support this.
 // UNSUPPORTED: gcc-5, gcc-6
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
index c7ddbebed..93b65e2c7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
@@ -8,10 +8,9 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
index b6a1cfa46..2fe7db3e9 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
@@ -8,10 +8,9 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
index 8a7b9bcf2..ef9c36ed7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
@@ -9,10 +9,9 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
-// Aligned allocation was not provided before macosx10.14 and as a result we
-// get availability errors when the deployment target is older than macosx10.14.
+// Aligned allocation was not provided before macosx10.12 and as a result we
+// get availability errors when the deployment target is older than macosx10.13.
 // However, AppleClang 10 (and older) don't trigger availability errors.
-// XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
-- 
GitLab


From c6fd2de6a1213b2bd56e1ee611b1fec18ecbd65d Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 20 Jan 2019 01:21:35 +0000
Subject: [PATCH 063/137] Fix aligned allocation availability XFAILs after
 D56445.

D56445 bumped the minimum Mac OS X version required for aligned
allocation from 10.13 to 10.14. This caused libc++ tests depending
on the old value to break.

This patch updates the XFAILs for those tests to include 10.13.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351670 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../new.delete.array/delete_align_val_t_replace.pass.cpp  | 8 +++++---
 .../new.delete/new.delete.array/new_align_val_t.pass.cpp  | 8 +++++---
 .../new.delete.array/new_align_val_t_nothrow.pass.cpp     | 8 +++++---
 .../new_align_val_t_nothrow_replace.pass.cpp              | 8 +++++---
 .../new.delete.single/delete_align_val_t_replace.pass.cpp | 8 +++++---
 .../new.delete/new.delete.single/new_align_val_t.pass.cpp | 8 +++++---
 .../new.delete.single/new_align_val_t_nothrow.pass.cpp    | 8 +++++---
 .../new_align_val_t_nothrow_replace.pass.cpp              | 8 +++++---
 8 files changed, 40 insertions(+), 24 deletions(-)

diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
index acbd2ee94..de09a7555 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
@@ -16,9 +16,11 @@
 // None of the current GCC compilers support this.
 // UNSUPPORTED: gcc-5, gcc-6
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13.
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
index 7495efb6b..bd99495e5 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
@@ -14,9 +14,11 @@
 // FIXME change this to XFAIL.
 // UNSUPPORTED: no-aligned-allocation && !gcc
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13.
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
index e324b9382..a83678769 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
@@ -14,9 +14,11 @@
 // FIXME turn this into an XFAIL
 // UNSUPPORTED: no-aligned-allocation && !gcc
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13.
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
index cdbf50263..5fbcc5ce7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
@@ -9,9 +9,11 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13.
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
index 2ac87e3ab..63e797480 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
@@ -15,9 +15,11 @@
 // None of the current GCC compilers support this.
 // UNSUPPORTED: gcc-5, gcc-6
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
index 93b65e2c7..d0d4b98ae 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
@@ -8,9 +8,11 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13.
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
index 2fe7db3e9..d0990c058 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
@@ -8,9 +8,11 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
index ef9c36ed7..fa8dc13cf 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
@@ -9,9 +9,11 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // UNSUPPORTED: sanitizer-new-delete
 
-// Aligned allocation was not provided before macosx10.12 and as a result we
-// get availability errors when the deployment target is older than macosx10.13.
-// However, AppleClang 10 (and older) don't trigger availability errors.
+// Aligned allocation was not provided before macosx10.14 and as a result we
+// get availability errors when the deployment target is older than macosx10.14.
+// However, AppleClang 10 (and older) don't trigger availability errors, and
+// Clang < 8.0 doesn't warn for 10.13
+// XFAIL: !(apple-clang-9 || apple-clang-10 || clang-7) && availability=macosx10.13
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.12
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.11
 // XFAIL: !(apple-clang-9 || apple-clang-10) && availability=macosx10.10
-- 
GitLab


From 905ff2b2a8135ae4a44fbd05659c8d1b81018112 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Mon, 21 Jan 2019 09:52:34 +0000
Subject: [PATCH 064/137] Fix typos throughout the license files that somehow I
 and my reviewers all missed!

Thanks to Alex Bradbury for pointing this out, and the fact that I never
added the intended `legacy` anchor to the developer policy. Add that
anchor too. With hope, this will cause the links to all resolve
successfully.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351731 91177308-0d34-0410-b5e6-96231b3b80d8
---
 LICENSE.TXT | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE.TXT b/LICENSE.TXT
index 4af93bba1..e159d2834 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -234,7 +234,7 @@ mechanisms:
    file.
 
 ==============================================================================
-Legacy LLVM License (ttps://llvm.org/docs/DeveloperPolicy.html#legacy):
+Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy):
 ==============================================================================
 
 The libc++ library is dual licensed under both the University of Illinois
-- 
GitLab


From cb6b6cda0f11ffa65ce6a6d9ca8b0200eb670f6c Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Tue, 22 Jan 2019 00:31:09 +0000
Subject: [PATCH 065/137] Update with issues to be moved in San Diego

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351770 91177308-0d34-0410-b5e6-96231b3b80d8
---
 www/upcoming_meeting.html | 99 +++++++++++++--------------------------
 1 file changed, 32 insertions(+), 67 deletions(-)

diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index 0b88d1c66..afd717fc7 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -49,6 +49,7 @@
   <h3>Paper Status</h3>
 	<table border="1">
 	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th></tr>
+<!-- 
 	<tr><td><a href="https://wg21.link/P0487R0">P0487R0</a></td><td>LWG</td><td>Fixing operator&gt;&gt; (basic_istream&amp;, CharT*) (LWG 2499)</td><td>San Diego</td><td><i> </i></td></tr>
 	<tr><td><a href="https://wg21.link/P0602R3">P0602R3</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td><i> </i></td></tr>
 	<tr><td><a href="https://wg21.link/P0655R0">P0655R0</a></td><td>LWG</td><td>visit&lt;R&gt;: Explicit Return Type for visit</td><td>San Diego</td><td><i> </i></td></tr>
@@ -58,6 +59,7 @@
 	<tr><td><a href="https://wg21.link/P1032R0">P1032R0</a></td><td>LWG</td><td>Misc constexpr bits</td><td>San Diego</td><td><i> </i></td></tr>
 	<tr><td><a href="http://wiki.edg.com/pub/LWGBatavia2018/LibraryWorkingGroup/D1148R0a.pdf">D1148</a></td><td>LWG</td><td>Cleaning up Clause 20</td><td>San Diego</td><td><i> </i></td></tr>
 	<tr><td><a href="http://wiki.edg.com/pub/LWGBatavia2018/LibraryWorkingGroup/D1163R0V2.pdf">D1163</a></td><td>LWG</td><td>Explicitly Implicifying explicit Constructors</td><td>San Diego</td><td><i> </i></td></tr>
+ -->
 	</table>
 
 
@@ -65,39 +67,22 @@
   <table id="issues" border="1">
 	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
 
-<tr><td><a href="https://wg21.link/LWG2183">2183</a></td><td>Muddled allocator requirements for <tt>match_results</tt> constructors</td><td>San Diego</td><td>Complete</td></tr>
-<tr><td><a href="https://wg21.link/LWG2184">2184</a></td><td>Muddled allocator requirements for <tt>match_results</tt> assignments</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG2412">2412</a></td><td><tt>promise::set_value()</tt> and <tt>promise::get_future()</tt> should not race</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td><code>filesystem::copy()</code> won't create a symlink to a directory</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG2697">2697</a></td><td>[concurr.ts] Behavior of <tt>future/shared_future</tt> unwrapping constructor when given an invalid <tt>future</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG2936">2936</a></td><td>Path comparison is defined in terms of the generic format</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG2943">2943</a></td><td>Problematic specification of the wide version of <tt>basic_filebuf::open</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG2960">2960</a></td><td>[fund.ts.v3] <tt>nonesuch</tt> is insufficiently useless</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG2995">2995</a></td><td><tt>basic_stringbuf</tt> default constructor forbids it from using SSO capacity</td><td>San Diego</td><td><i>We know how to do this</i></td></tr>
-<tr><td><a href="https://wg21.link/LWG2996">2996</a></td><td>Missing rvalue overloads for <tt>shared_ptr</tt> operations</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3008">3008</a></td><td><tt>make_shared</tt> (sub)object destruction semantics are not specified</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3025">3025</a></td><td>Map-like container deduction guides should use <tt>pair&lt;Key, T&gt;</tt>, not <tt>pair&lt;const Key, T&gt;</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3031">3031</a></td><td>Algorithms and predicates with non-const reference arguments</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3037">3037</a></td><td><tt>polymorphic_allocator</tt> and incomplete types</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3038">3038</a></td><td><tt>polymorphic_allocator::allocate</tt> should not allow integer overflow to create vulnerabilities</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3054">3054</a></td><td><tt>uninitialized_copy</tt> appears to not be able to meet its exception-safety guarantee</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3065">3065</a></td><td>LWG 2989 missed that all <tt>path</tt>'s other operators should be hidden friends as well</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3096">3096</a></td><td><tt>path::lexically_relative</tt> is confused by trailing slashes</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3116">3116</a></td><td><tt><i>OUTERMOST_ALLOC_TRAITS</i></tt> needs <tt>remove_reference_t</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3122">3122</a></td><td><tt>__cpp_lib_chrono_udls</tt> was accidentally dropped</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3127">3127</a></td><td><tt>basic_osyncstream::rdbuf</tt> needs a <tt>const_cast</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3128">3128</a></td><td><tt>strstream::rdbuf</tt> needs a <tt>const_cast</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3129">3129</a></td><td><tt>regex_token_iterator</tt> constructor uses wrong pointer arithmetic</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3130">3130</a></td><td>&sect;[input.output] needs many <tt>addressof</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3131">3131</a></td><td><tt>addressof</tt> all the things</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3132">3132</a></td><td>Library needs to ban macros named <tt>expects</tt> or <tt>ensures</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3134">3134</a></td><td>[fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3137">3137</a></td><td>Header for <tt>__cpp_lib_to_chars</tt></td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3145">3145</a></td><td><tt>file_clock</tt> breaks ABI for C++17 implementations</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3147">3147</a></td><td>Definitions of "likely" and "unlikely" are likely to cause problems</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3148">3148</a></td><td><tt>&lt;concepts&gt;</tt> should be freestanding</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3153">3153</a></td><td><tt>Common</tt> and <tt>common_type</tt> have too little in common</td><td>San Diego</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3154">3154</a></td><td><tt>Common</tt> and <tt>CommonReference</tt> have a common defect</td><td>San Diego</td><td></td></tr>
+<table border="1">
+<tr><th>Issue #</th><th>Has P/R</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
+<tr><td><a href="https://wg21.link/LWG3012">3012</a></td><td>Yes</td><td><tt>atomic&lt;T&gt;</tt> is unimplementable for non-<tt>is_trivially_copy_constructible T</tt></td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3040">3040</a></td><td>Yes</td><td><tt>basic_string_view::starts_with</tt> <i>Effects</i> are incorrect</td><td>Kona</td><td>Complete</td></tr>
+<tr><td><a href="https://wg21.link/LWG3077">3077</a></td><td>Yes</td><td><tt>(push|emplace)_back</tt> should invalidate the <tt>end</tt> iterator</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
+<tr><td><a href="https://wg21.link/LWG3087">3087</a></td><td>Yes</td><td>One final <tt>&amp;x</tt> in &sect;[list.ops]</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
+<tr><td><a href="https://wg21.link/LWG3101">3101</a></td><td>Yes</td><td><tt>span</tt>'s <tt>Container</tt> constructors need another constraint</td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3112">3112</a></td><td>Yes</td><td><tt>system_error</tt> and <tt>filesystem_error</tt> constructors taking a <tt>string</tt> may not be able  to meet their postconditions</td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3119">3119</a></td><td>Yes</td><td>Program-definedness of closure types</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
+<tr><td><a href="https://wg21.link/LWG3133">3133</a></td><td>Yes</td><td>Modernizing numeric type requirements</td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3144">3144</a></td><td>Yes</td><td><tt>span</tt> does not have a <tt>const_pointer</tt> typedef</td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3173">3173</a></td><td>Yes</td><td>Enable CTAD for <i><tt>ref-view</tt></i></td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3179">3179</a></td><td>Yes</td><td><tt>subrange</tt> should always model <tt>Range</tt></td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3180">3180</a></td><td>Yes</td><td>Inconsistently named return type for <tt>ranges::minmax_element</tt></td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3182">3182</a></td><td>Yes</td><td>Specification of <tt>Same</tt> could be clearer</td><td>Kona</td><td></td></tr>
+</table>
 
 </table>
 
@@ -109,42 +94,22 @@
 
 <h3>Comments about the issues</h3>
 <ul>
-<li>2183 - We're missing tests for match_results (copy ctor, move ctor). I committed them in r344988.</li>
-<li>2184 - We're missing tests for match_results (copy assign, move assing). I wrote them. Unfortunately, the move-assign test fails.</li>
-<li>2412 - </li>
-<li>2682 - Eric? </li>
-<li>2697 - </li>
-<li>2936 - </li>
-<li>2943 - Eric? I suspect that this is no change for us.</li>
-<li>2960 - </li>
-<li>2995 - We used to do this. Reverting r320604 and r321124 will get us back there.</li>
-<li>2996 - </li>
-<li>3008 - </li>
-<li>3025 - </li>
-<li>3031 - Marshall says: I don't think we have to do anything for this issue. Maybe some tests; maybe a static_assert.</li>
-<li>3037 - Marshall says: We don't have std::polymorphic_allocator yet.</li>
-<li>3038 - Marshall says: We don't have std::polymorphic_allocator yet.</li>
-<li>3054 - Marshall says: We already do this; may need to update some tests.</li>
-<li>3065 - </li>
-<li>3096 - Eric? </li>
-<li>3116 - </li>
-<li>3122 - Marshall says I have updated the comments in &lt;version&gt; and in the tests.</li>
-<li>3127 - Marshall says: We don't have basic_osyncstream yet.</li>
-<li>3128 - </li>
-<li>3129 - Marshall says: This is an easy change; I think this is more wording cleanup than anything. I will prepare a patch</li>
-<li>3130 - </li>
-<li>3131 - Only changes 11 & 12 affect libc++. </li>
-<li>3132 - Marshall says: I don't think we have to do anything for this issue</li>
-<li>3134 - Marshall says: I don't think we have to do anything for this issue</li>
-<li>3137 - Marshall says I have updated the comments in &lt;version&gt; and in the tests.</li>
-<li>3145 - Eric? </li>
-<li>3147 - Marshall - I don't think we have to do anything for this issue</li>
-<li>3148 - </li>
-<li>3153 - </li>
-<li>3154 - </li>
+<li>3012 - </li>
+<li>3040 - We already do this</li>
+<li>3077 - No changes required</li>
+<li>3087 - No changes required</li>
+<li>3101 - I will take care of this</li>
+<li>3112 - Eric - can you take a look?</li>
+<li>3119 - No changes required</li>
+<li>3133 - </li>
+<li>3144 - I will take care of this; we already do this, but a "not in standard" note</li>
+<li>3173 - We don't have ranges yet</li>
+<li>3179 - We don't have ranges yet</li>
+<li>3180 - We don't have ranges yet</li>
+<li>3182 - We don't have concepts yet</li>
 </ul>
 
-<p>Last Updated: 29-Oct-2018</p>
+<p>Last Updated: 21-Jan-2019</p>
 </div>
 </body>
 </html>
-- 
GitLab


From 844067dc7604bc1a561b608e66756f0b4e685834 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Tue, 22 Jan 2019 01:05:58 +0000
Subject: [PATCH 066/137] Updated issue 3144

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351773 91177308-0d34-0410-b5e6-96231b3b80d8
---
 www/upcoming_meeting.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index afd717fc7..ab1145bb5 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -77,7 +77,7 @@
 <tr><td><a href="https://wg21.link/LWG3112">3112</a></td><td>Yes</td><td><tt>system_error</tt> and <tt>filesystem_error</tt> constructors taking a <tt>string</tt> may not be able  to meet their postconditions</td><td>Kona</td><td></td></tr>
 <tr><td><a href="https://wg21.link/LWG3119">3119</a></td><td>Yes</td><td>Program-definedness of closure types</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
 <tr><td><a href="https://wg21.link/LWG3133">3133</a></td><td>Yes</td><td>Modernizing numeric type requirements</td><td>Kona</td><td></td></tr>
-<tr><td><a href="https://wg21.link/LWG3144">3144</a></td><td>Yes</td><td><tt>span</tt> does not have a <tt>const_pointer</tt> typedef</td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3144">3144</a></td><td>Yes</td><td><tt>span</tt> does not have a <tt>const_pointer</tt> typedef</td><td>Kona</td><td>Patch available</td></tr>
 <tr><td><a href="https://wg21.link/LWG3173">3173</a></td><td>Yes</td><td>Enable CTAD for <i><tt>ref-view</tt></i></td><td>Kona</td><td></td></tr>
 <tr><td><a href="https://wg21.link/LWG3179">3179</a></td><td>Yes</td><td><tt>subrange</tt> should always model <tt>Range</tt></td><td>Kona</td><td></td></tr>
 <tr><td><a href="https://wg21.link/LWG3180">3180</a></td><td>Yes</td><td>Inconsistently named return type for <tt>ranges::minmax_element</tt></td><td>Kona</td><td></td></tr>
@@ -102,7 +102,7 @@
 <li>3112 - Eric - can you take a look?</li>
 <li>3119 - No changes required</li>
 <li>3133 - </li>
-<li>3144 - I will take care of this; we already do this, but a "not in standard" note</li>
+<li>3144 - Patch: <a href="https://reviews.llvm.org/D57039">D57039</a></li>
 <li>3173 - We don't have ranges yet</li>
 <li>3179 - We don't have ranges yet</li>
 <li>3180 - We don't have ranges yet</li>
-- 
GitLab


From 56e3b48754bdca65c45cd604a312b42aa10e1a36 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Tue, 22 Jan 2019 16:22:53 +0000
Subject: [PATCH 067/137] Note that we have a patch for LWG3101

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351832 91177308-0d34-0410-b5e6-96231b3b80d8
---
 www/upcoming_meeting.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index ab1145bb5..44db2c472 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -73,7 +73,7 @@
 <tr><td><a href="https://wg21.link/LWG3040">3040</a></td><td>Yes</td><td><tt>basic_string_view::starts_with</tt> <i>Effects</i> are incorrect</td><td>Kona</td><td>Complete</td></tr>
 <tr><td><a href="https://wg21.link/LWG3077">3077</a></td><td>Yes</td><td><tt>(push|emplace)_back</tt> should invalidate the <tt>end</tt> iterator</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
 <tr><td><a href="https://wg21.link/LWG3087">3087</a></td><td>Yes</td><td>One final <tt>&amp;x</tt> in &sect;[list.ops]</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
-<tr><td><a href="https://wg21.link/LWG3101">3101</a></td><td>Yes</td><td><tt>span</tt>'s <tt>Container</tt> constructors need another constraint</td><td>Kona</td><td></td></tr>
+<tr><td><a href="https://wg21.link/LWG3101">3101</a></td><td>Yes</td><td><tt>span</tt>'s <tt>Container</tt> constructors need another constraint</td><td>Kona</td><td>Patch available</td></tr>
 <tr><td><a href="https://wg21.link/LWG3112">3112</a></td><td>Yes</td><td><tt>system_error</tt> and <tt>filesystem_error</tt> constructors taking a <tt>string</tt> may not be able  to meet their postconditions</td><td>Kona</td><td></td></tr>
 <tr><td><a href="https://wg21.link/LWG3119">3119</a></td><td>Yes</td><td>Program-definedness of closure types</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
 <tr><td><a href="https://wg21.link/LWG3133">3133</a></td><td>Yes</td><td>Modernizing numeric type requirements</td><td>Kona</td><td></td></tr>
@@ -98,7 +98,7 @@
 <li>3040 - We already do this</li>
 <li>3077 - No changes required</li>
 <li>3087 - No changes required</li>
-<li>3101 - I will take care of this</li>
+<li>3101 - Patch: <a href="https://reviews.llvm.org/D57058">D57058</a></li>
 <li>3112 - Eric - can you take a look?</li>
 <li>3119 - No changes required</li>
 <li>3133 - </li>
-- 
GitLab


From 8734fa79ec13861337ccae6afb18007559d4cf6a Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 22 Jan 2019 17:45:00 +0000
Subject: [PATCH 068/137] [libcxx] Include <cstring> in tests that use strcmp

Reviewed as https://reviews.llvm.org/D56503.
Thanks to Andrey Maksimov for the patch.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351847 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../depr.strstream/depr.strstream.cons/default.pass.cpp       | 3 ++-
 .../streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp     | 3 ++-
 .../streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp     | 3 ++-
 .../support.rtti/type.info/type_info.pass.cpp                 | 4 ++--
 4 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
index a1251ae58..ff68a3d1d 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
@@ -14,6 +14,7 @@
 
 #include <strstream>
 #include <cassert>
+#include <cstring>
 #include <string>
 
 int main()
@@ -30,6 +31,6 @@ int main()
     inout >> i >> d >> s;
     assert(i == 123);
     assert(d == 4.5);
-    assert(strcmp(s.c_str(), "dog") == 0);
+    assert(std::strcmp(s.c_str(), "dog") == 0);
     inout.freeze(false);
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
index 20e785383..7c5f6b9d6 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <streambuf>
 #include <cassert>
+#include <cstring>
 
 struct test
     : public std::basic_streambuf<char>
@@ -36,5 +37,5 @@ int main()
     t.setg(input, input, input+7);
     char output[sizeof(input)] = {0};
     assert(t.sgetn(output, 10) == 7);
-    assert(strcmp(input, output) == 0);
+    assert(std::strcmp(input, output) == 0);
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
index 728697f7c..15d374041 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <streambuf>
 #include <cassert>
+#include <cstring>
 
 struct test
     : public std::basic_streambuf<char>
@@ -38,6 +39,6 @@ int main()
         char out[sizeof(in)] = {0};
         t.setp(out, out+sizeof(out));
         assert(t.sputn(in, sizeof(in)) == sizeof(in));
-        assert(strcmp(in, out) == 0);
+        assert(std::strcmp(in, out) == 0);
     }
 }
diff --git a/test/std/language.support/support.rtti/type.info/type_info.pass.cpp b/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
index d0a6a0fd6..fec07526a 100644
--- a/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
+++ b/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
@@ -25,8 +25,8 @@ int main()
     const std::type_info& t3 = typeid(short);
     assert(t1 != t3);
     assert(!t1.before(t2));
-    assert(strcmp(t1.name(), t2.name()) == 0);
-    assert(strcmp(t1.name(), t3.name()) != 0);
+    assert(std::strcmp(t1.name(), t2.name()) == 0);
+    assert(std::strcmp(t1.name(), t3.name()) != 0);
   }
   {
     // type_info has a protected constructor taking a string literal. This
-- 
GitLab


From b9b2b3f11e38f326dded221379c834572f52c1a0 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Tue, 22 Jan 2019 22:01:13 +0000
Subject: [PATCH 069/137] While reviewing D57058, Louis had some questions
 about the existing span constructor tests. They were not testing the stuff
 that they said they were. Updated the tests to test what they should have
 been doing

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351887 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../views/span.cons/container.fail.cpp        | 80 +++++++++++--------
 .../views/span.cons/container.pass.cpp        | 25 +++++-
 2 files changed, 69 insertions(+), 36 deletions(-)

diff --git a/test/std/containers/views/span.cons/container.fail.cpp b/test/std/containers/views/span.cons/container.fail.cpp
index 202e6848c..cfffa57a1 100644
--- a/test/std/containers/views/span.cons/container.fail.cpp
+++ b/test/std/containers/views/span.cons/container.fail.cpp
@@ -26,9 +26,10 @@
 
 #include <span>
 #include <cassert>
-#include <list>
-#include <forward_list>
 #include <deque>
+#include <forward_list>
+#include <list>
+#include <vector>
 
 #include "test_macros.h"
 
@@ -65,52 +66,67 @@ private:
 int main ()
 {
 
-//  Missing size and/or data
+//  Making non-const spans from const sources (a temporary binds to `const &`)
     {
     std::span<int>    s1{IsAContainer<int>()};          // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s2{IsAContainer<int>()};          // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
-    std::span<int>    s3{NotAContainerNoData<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s4{NotAContainerNoData<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
-    std::span<int>    s5{NotAContainerNoSize<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s6{NotAContainerNoSize<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
-    std::span<int>    s7{NotAContainerPrivate<int>()};  // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s8{NotAContainerPrivate<int>()};  // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
+    std::span<int, 0> s2{IsAContainer<int>()};          // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}} 
+    std::span<int>    s3{std::vector<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
+    std::span<int, 0> s4{std::vector<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}} 
+    }
+
+//  Missing size and/or data
+    {
+    std::span<const int>    s1{NotAContainerNoData<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<const int, 0> s2{NotAContainerNoData<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
+    std::span<const int>    s3{NotAContainerNoSize<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<const int, 0> s4{NotAContainerNoSize<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
+    std::span<const int>    s5{NotAContainerPrivate<int>()};  // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<const int, 0> s6{NotAContainerPrivate<int>()};  // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
 
 //  Again with the standard containers
-    std::span<int>    s11{std::deque<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s12{std::deque<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
-    std::span<int>    s13{std::list<int>()};            // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s14{std::list<int>()};            // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
-    std::span<int>    s15{std::forward_list<int>()};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<int, 0> s16{std::forward_list<int>()};    // expected-error {{no matching constructor for initialization of 'std::span<int, 0>'}}
+    std::span<const int>    s11{std::deque<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<const int, 0> s12{std::deque<int>()};           // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
+    std::span<const int>    s13{std::list<int>()};            // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<const int, 0> s14{std::list<int>()};            // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
+    std::span<const int>    s15{std::forward_list<int>()};    // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<const int, 0> s16{std::forward_list<int>()};    // expected-error {{no matching constructor for initialization of 'std::span<const int, 0>'}}
     }
 
 //  Not the same type
     {
-    std::span<float>    s1{IsAContainer<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
-    std::span<float, 0> s2{IsAContainer<int>()};   // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
+    IsAContainer<int> c;
+    std::span<float>    s1{c};   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
+    std::span<float, 0> s2{c};   // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
     }
 
 //  CV wrong (dynamically sized)
     {
-    std::span<               int> s1{IsAContainer<const          int>()};   // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s2{IsAContainer<      volatile int>()};   // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s3{IsAContainer<const volatile int>()};   // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<const          int> s4{IsAContainer<      volatile int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const          int> s5{IsAContainer<const volatile int>()};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<      volatile int> s6{IsAContainer<const          int>()};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    std::span<      volatile int> s7{IsAContainer<const volatile int>()};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
+    IsAContainer<const          int> c;
+    IsAContainer<const volatile int> cv;
+    IsAContainer<      volatile int> v;
+    
+    std::span<               int> s1{c};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
+    std::span<               int> s2{v};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
+    std::span<               int> s3{cv};   // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
+    std::span<const          int> s4{v};    // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<const          int> s5{cv};   // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
+    std::span<      volatile int> s6{c};    // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
+    std::span<      volatile int> s7{cv};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
     }
 
 //  CV wrong (statically sized)
     {
-    std::span<               int,1> s1{IsAContainer<const          int>()}; // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
-    std::span<               int,1> s2{IsAContainer<      volatile int>()}; // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
-    std::span<               int,1> s3{IsAContainer<const volatile int>()}; // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
-    std::span<const          int,1> s4{IsAContainer<      volatile int>()}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 1>'}}
-    std::span<const          int,1> s5{IsAContainer<const volatile int>()}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 1>'}}
-    std::span<      volatile int,1> s6{IsAContainer<const          int>()}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
-    std::span<      volatile int,1> s7{IsAContainer<const volatile int>()}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
+    IsAContainer<const          int> c;
+    IsAContainer<const volatile int> cv;
+    IsAContainer<      volatile int> v;
+
+    std::span<               int,1> s1{c};  // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
+    std::span<               int,1> s2{v};  // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
+    std::span<               int,1> s3{cv}; // expected-error {{no matching constructor for initialization of 'std::span<int, 1>'}}
+    std::span<const          int,1> s4{v};  // expected-error {{no matching constructor for initialization of 'std::span<const int, 1>'}}
+    std::span<const          int,1> s5{cv}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 1>'}}
+    std::span<      volatile int,1> s6{c};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
+    std::span<      volatile int,1> s7{cv}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
     }
 
 }
diff --git a/test/std/containers/views/span.cons/container.pass.cpp b/test/std/containers/views/span.cons/container.pass.cpp
index 8bd5f613d..4e9001bff 100644
--- a/test/std/containers/views/span.cons/container.pass.cpp
+++ b/test/std/containers/views/span.cons/container.pass.cpp
@@ -73,6 +73,18 @@ void checkCV()
     std::span<      volatile int,3> s3{v};  // a span<      volatile int> pointing at const int.
     std::span<const volatile int,3> s4{v};  // a span<const volatile int> pointing at int.
     }
+
+//  Constructing a const view from a temporary
+    {
+    std::span<const int>    s1{IsAContainer<int>()};
+    std::span<const int, 0> s2{IsAContainer<int>()};
+    std::span<const int>    s3{std::vector<int>()};
+    std::span<const int, 0> s4{std::vector<int>()};
+    (void) s1;
+    (void) s2;
+    (void) s3;
+    (void) s4;
+    }
 }
 
 
@@ -92,10 +104,15 @@ template <typename T>
 void testRuntimeSpan()
 {
     IsAContainer<T> val{};
-    std::span<const T>    s1{val};
-    std::span<const T, 1> s2{val};
-    assert(s1.data() == val.getV() && s1.size() == 1);
-    assert(s2.data() == val.getV() && s2.size() == 1);
+    const IsAContainer<T> cVal;
+    std::span<T>          s1{val};
+    std::span<const T>    s2{cVal};
+    std::span<T, 1>       s3{val};
+    std::span<const T, 1> s4{cVal};
+    assert(s1.data() == val.getV()  && s1.size() == 1);
+    assert(s2.data() == cVal.getV() && s2.size() == 1);
+    assert(s3.data() == val.getV()  && s3.size() == 1);
+    assert(s4.data() == cVal.getV() && s4.size() == 1);
 }
 
 struct A{};
-- 
GitLab


From bd03c298c3eeda2621a63fa9f96cd1891893892d Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Wed, 23 Jan 2019 10:11:41 +0000
Subject: [PATCH 070/137] Mark thread.condition.condvarany/wait_for.pass.cpp as
 flaky

Reported on the NetBSD 8 buildbot.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351937 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.condition.condvarany/wait_for.pass.cpp               | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
index 57f6f7683..ec4eb3398 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
@@ -8,6 +8,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST.
+
 // <condition_variable>
 
 // class condition_variable_any;
-- 
GitLab


From 3f9884bec198889bea8bb43230bb0c74650f52a8 Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Wed, 23 Jan 2019 11:36:19 +0000
Subject: [PATCH 071/137] Mark more tests flaky

Reported on the NetBSD 8 buildbot


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351944 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.condition.condvar/wait_until_pred.pass.cpp           | 2 ++
 .../thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
index f719e751f..8307a52c0 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
@@ -8,6 +8,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST.
+
 // <condition_variable>
 
 // class condition_variable;
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
index ddf3341d0..7726337c8 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
@@ -9,6 +9,8 @@
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
+// FLAKY_TEST.
+
 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
-- 
GitLab


From 97579ac7acf4a53810da2b44807f860b0abe92f0 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Wed, 23 Jan 2019 18:27:22 +0000
Subject: [PATCH 072/137] Commit D11348: 'Win32 support: wcsnrtombs and
 mbsnrtowcs don't handle null output buffers correctly' which has been hanging
 around for a long time

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351971 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/support/win32/support.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/support/win32/support.cpp b/src/support/win32/support.cpp
index b4f1e22f3..4c9a4b3a5 100644
--- a/src/support/win32/support.cpp
+++ b/src/support/win32/support.cpp
@@ -61,6 +61,11 @@ size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src,
     size_t result = 0;
     bool have_result = false;
 
+    // If dst is null then max_dest_chars should be ignored according to the
+    // standard.  Setting max_dest_chars to a large value has this effect.
+    if (!dst)
+        max_dest_chars = static_cast<size_t>(-1);
+
     while ( source_remaining ) {
         if ( dst && dest_converted >= max_dest_chars )
             break;
@@ -114,6 +119,11 @@ size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src,
     bool have_result = false;
     bool terminator_found = false;
 
+    // If dst is null then dst_size_bytes should be ignored according to the
+    // standard.  Setting dest_remaining to a large value has this effect.
+    if (!dst)
+        dest_remaining = static_cast<size_t>(-1);
+
     while ( source_converted != max_source_chars ) {
         if ( ! dest_remaining )
             break;
-- 
GitLab


From 50918087289b582f3253f5526dad3d21295a09c2 Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Wed, 23 Jan 2019 21:45:02 +0000
Subject: [PATCH 073/137] Correct mark for flaky tests

Add missing trailing dot.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351983 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.condition/thread.condition.condvar/wait_for.pass.cpp | 2 +-
 .../thread.condition.condvarany/notify_one.pass.cpp             | 2 +-
 .../thread.lock/thread.lock.guard/adopt_lock.pass.cpp           | 2 +-
 .../thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp   | 2 +-
 .../thread.lock.shared.cons/mutex_try_to_lock.pass.cpp          | 2 +-
 .../thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp   | 2 +-
 .../thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
index b7088fb31..f34b230c2 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// FLAKY_TEST
+// FLAKY_TEST.
 
 // <condition_variable>
 
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
index dc124cbe8..e5c0a0943 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// FLAKY_TEST
+// FLAKY_TEST.
 
 // <condition_variable>
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
index 9a057d011..273a48813 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// FLAKY_TEST
+// FLAKY_TEST.
 
 // <mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
index a3ab48984..84353486b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// FLAKY_TEST
+// FLAKY_TEST.
 
 // <mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
index d0ca30c93..4375a2b99 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
@@ -9,7 +9,7 @@
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11
 
-// FLAKY_TEST
+// FLAKY_TEST.
 
 // <shared_mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
index 383d3278a..30897b3d8 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// FLAKY_TEST
+// FLAKY_TEST.
 
 // <mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
index 37e50815d..536a0d7d2 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// FLAKY_TEST
+// FLAKY_TEST.
 
 // <mutex>
 
-- 
GitLab


From 7cab086218c8f1326aae274568cccf761234dfec Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Wed, 23 Jan 2019 22:35:57 +0000
Subject: [PATCH 074/137] Mark another test as flaky

Reported on the NetBSD 8 buildbot.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351988 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.condition.condvarany/wait_until_pred.pass.cpp        | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
index 5d1c1793d..0216688d7 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
@@ -8,6 +8,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST.
+
 // <condition_variable>
 
 // class condition_variable_any;
-- 
GitLab


From 96442b73411afa43db3ffe988c08d7a9a142a1db Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Wed, 23 Jan 2019 22:49:44 +0000
Subject: [PATCH 075/137] [test] Define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
 in msvc_stdlib_force_include.hpp

...so the tests under test/std/utilities/any continue to
compile with MSVC's standard library.

While we're here, let's test >C++17 features when _HAS_CXX20.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351991 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/support/msvc_stdlib_force_include.hpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/test/support/msvc_stdlib_force_include.hpp b/test/support/msvc_stdlib_force_include.hpp
index c3dd3aad9..fcf64d78c 100644
--- a/test/support/msvc_stdlib_force_include.hpp
+++ b/test/support/msvc_stdlib_force_include.hpp
@@ -78,10 +78,14 @@ const AssertionDialogAvoider assertion_dialog_avoider{};
 
 #include <ciso646>
 
-#if _HAS_CXX17
+#if _HAS_CXX20
+    #define TEST_STD_VER 99
+#elif _HAS_CXX17
     #define TEST_STD_VER 17
-#else // _HAS_CXX17
+#else // !(_HAS_CXX20 || _HAS_CXX17)
     #define TEST_STD_VER 14
-#endif // _HAS_CXX17
+#endif
+
+#define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
 
 #endif // SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP
-- 
GitLab


From 01a665a876ab04aa212a3a80c9c1ce2e685bf5c4 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Wed, 23 Jan 2019 23:06:18 +0000
Subject: [PATCH 076/137] Apply D28248: 'Work around GCC PR37804'. Thanks to
 mdaniels for the patch

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351993 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/__tree                                |  7 +++++++
 .../associative/map/gcc_workaround.pass.cpp   | 21 +++++++++++++++++++
 .../associative/set/gcc_workaround.pass.cpp   | 21 +++++++++++++++++++
 3 files changed, 49 insertions(+)
 create mode 100644 test/std/containers/associative/map/gcc_workaround.pass.cpp
 create mode 100644 test/std/containers/associative/set/gcc_workaround.pass.cpp

diff --git a/include/__tree b/include/__tree
index 4144a9599..9f0931ee9 100644
--- a/include/__tree
+++ b/include/__tree
@@ -26,6 +26,13 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if defined(__GNUC__) && !defined(__clang__) // gcc.gnu.org/PR37804
+template <class, class, class, class> class _LIBCPP_TEMPLATE_VIS map;
+template <class, class, class, class> class _LIBCPP_TEMPLATE_VIS multimap;
+template <class, class, class> class _LIBCPP_TEMPLATE_VIS set;
+template <class, class, class> class _LIBCPP_TEMPLATE_VIS multiset;
+#endif
+
 template <class _Tp, class _Compare, class _Allocator> class __tree;
 template <class _Tp, class _NodePtr, class _DiffType>
     class _LIBCPP_TEMPLATE_VIS __tree_iterator;
diff --git a/test/std/containers/associative/map/gcc_workaround.pass.cpp b/test/std/containers/associative/map/gcc_workaround.pass.cpp
new file mode 100644
index 000000000..622449fac
--- /dev/null
+++ b/test/std/containers/associative/map/gcc_workaround.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// Tests workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=37804
+
+#include <map>
+std::map<int,int>::iterator it;
+#include <set>
+using std::set;
+using std::multiset;
+
+int main(void)
+{
+       return 0;
+}
diff --git a/test/std/containers/associative/set/gcc_workaround.pass.cpp b/test/std/containers/associative/set/gcc_workaround.pass.cpp
new file mode 100644
index 000000000..2b923b773
--- /dev/null
+++ b/test/std/containers/associative/set/gcc_workaround.pass.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// Tests workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=37804
+
+#include <set>
+std::set<int> s;
+#include <map>
+using std::map;
+using std::multimap;
+
+int main(void)
+{
+       return 0;
+}
-- 
GitLab


From dd8f4539c4dcdc7499a892b62720078003eae6c0 Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Wed, 23 Jan 2019 23:24:43 +0000
Subject: [PATCH 077/137] Mark another test as flaky

Reported on the NetBSD 8 buildbot.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@351995 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.mutex.class/lock.pass.cpp                            | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
index f5be69b3d..912b647d3 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
@@ -8,6 +8,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST.
+
 // <mutex>
 
 // class mutex;
-- 
GitLab


From df2b82ce3166b55f478a15141a4edd1dd30f2ee4 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Thu, 24 Jan 2019 01:52:56 +0000
Subject: [PATCH 078/137] Uncomment the entire test, but mark as XFAIL on
 linux-gnu because it uses locales that aren't generally available there,
 similar to the other regex tests

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352006 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/std/re/re.alg/re.alg.match/awk.pass.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/std/re/re.alg/re.alg.match/awk.pass.cpp b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
index f0a62794b..4afc6b0ef 100644
--- a/test/std/re/re.alg/re.alg.match/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
@@ -16,6 +16,9 @@
 //                    regex_constants::match_flag_type flags
 //                                            = regex_constants::match_default);
 
+// TODO: investigation needed
+// XFAIL: linux-gnu
+
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
@@ -25,7 +28,6 @@
 
 int main()
 {
-#if 0
     {
         std::cmatch m;
         const char s[] = "a";
@@ -1388,5 +1390,4 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
-#endif
 }
-- 
GitLab


From f2f9af003297586bb707adedd7b716c9a407b335 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Thu, 24 Jan 2019 02:02:50 +0000
Subject: [PATCH 079/137] Change a couple of '&' to addressof(). NFC

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352007 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/regex | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/regex b/include/regex
index d47978037..c381b5116 100644
--- a/include/regex
+++ b/include/regex
@@ -6139,7 +6139,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {return  __match_;}
     _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const  {return &__match_;}
+    pointer operator->() const  {return _VSTD::addressof(__match_);}
 
     regex_iterator& operator++();
     _LIBCPP_INLINE_VISIBILITY
@@ -6163,7 +6163,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
                    const regex_type& __re, regex_constants::match_flag_type __m)
     : __begin_(__a),
       __end_(__b),
-      __pregex_(&__re),
+      __pregex_(_VSTD::addressof(__re)),
       __flags_(__m)
 {
     _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
@@ -6404,7 +6404,7 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
                              regex_constants::match_flag_type __m)
     : __position_(__a, __b, __re, __m),
       __n_(0),
-      __subs_(__submatches, __submatches + _Np)
+      __subs_(begin(__submatches), end(__submatches))
 {
     __init(__a, __b);
 }
-- 
GitLab


From 2a895e80879c69fc230b0e3c98cbb330ce8e3775 Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Thu, 24 Jan 2019 17:17:55 +0000
Subject: [PATCH 080/137] Mark another test as flaky

Reported on the NetBSD 8 buildbot.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352064 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.timedmutex.recursive/lock.pass.cpp                   | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
index a0dbde84b..aba747b95 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
@@ -8,6 +8,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// FLAKY_TEST.
+
 // <mutex>
 
 // class recursive_timed_mutex;
-- 
GitLab


From 42cbe7a2aa2339b22bf34cb7fa69bdd856d65a60 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Thu, 24 Jan 2019 19:09:22 +0000
Subject: [PATCH 081/137] [libcxx] Portability fix: unordered_set and
 unordered_multiset iterators are not required to be the same

The unordered_set and unordered_multiset iterators are specified in the standard as follows:

using iterator             = implementation-defined; // see [container.requirements]
using const_iterator       = implementation-defined; // see [container.requirements]
using local_iterator       = implementation-defined; // see [container.requirements]
using const_local_iterator = implementation-defined; // see [container.requirements]

The pairs iterator/const_iterator and local_iterator/const_local_iterator
are not required to be the same. The reasonable requirement would be that
iterator can convert to const_iterator and local_iterator can convert to
const_local_iterator. This patch weakens the check and makes the test
more portable.

Reviewed as https://reviews.llvm.org/D56493.
Thanks to Andrey Maksimov for the patch.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352083 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../containers/unord/iterator_difference_type.pass.cpp    | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/std/containers/unord/iterator_difference_type.pass.cpp b/test/std/containers/unord/iterator_difference_type.pass.cpp
index fe2a83a01..3f0b61e5f 100644
--- a/test/std/containers/unord/iterator_difference_type.pass.cpp
+++ b/test/std/containers/unord/iterator_difference_type.pass.cpp
@@ -51,10 +51,10 @@ void testUnorderedMap() {
 
 template <class Set, class ValueTp, class CPtrT>
 void testUnorderedSet() {
-  static_assert((std::is_same<typename Set::iterator,
-                             typename Set::const_iterator>::value), "");
-  static_assert((std::is_same<typename Set::local_iterator,
-                             typename Set::const_local_iterator>::value), "");
+  static_assert((std::is_convertible<typename Set::iterator,
+                                     typename Set::const_iterator>::value), "");
+  static_assert((std::is_convertible<typename Set::local_iterator,
+                                     typename Set::const_local_iterator>::value), "");
   typedef typename Set::difference_type Diff;
   {
     typedef typename Set::iterator It;
-- 
GitLab


From e7e7b2e6bdedc2b7cfb48511c1efc7c736e1c972 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Thu, 24 Jan 2019 19:20:19 +0000
Subject: [PATCH 082/137] D14686: 'Protect against overloaded comma in
 random_shuffle and improve tests' I had to cut back on the tests with this,
 because they were not C++03 friendly. Thanks to gribozavr for the patch

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352087 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/algorithm                             |  4 +--
 .../random_shuffle.pass.cpp                   | 28 ++++++++++++++++++-
 .../random_shuffle_rand.pass.cpp              | 19 ++++++++++++-
 3 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/include/algorithm b/include/algorithm
index 310256e61..b52d44522 100644
--- a/include/algorithm
+++ b/include/algorithm
@@ -2989,7 +2989,7 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
         _Dp __uid;
         __rs_default __g = __rs_get();
-        for (--__last, --__d; __first < __last; ++__first, --__d)
+        for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
         {
             difference_type __i = __uid(__g, _Pp(0, __d));
             if (__i != difference_type(0))
@@ -3011,7 +3011,7 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
     difference_type __d = __last - __first;
     if (__d > 1)
     {
-        for (--__last; __first < __last; ++__first, --__d)
+        for (--__last; __first < __last; ++__first, (void) --__d)
         {
             difference_type __i = __rand(__d);
             if (__i != difference_type(0))
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
index 6a85b995c..6ae7eb964 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
@@ -18,17 +18,43 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_iterators.h"
+
+template <class Iter>
+void
+test_with_iterator()
+{
+    int empty[] = {};
+    std::random_shuffle(Iter(empty), Iter(empty));
+
+    const int all_elements[] = {1, 2, 3, 4};
+    int           shuffled[] = {1, 2, 3, 4};
+    const unsigned size = sizeof(all_elements)/sizeof(all_elements[0]);
+
+    std::random_shuffle(Iter(shuffled), Iter(shuffled+size));
+    assert(std::is_permutation(shuffled, shuffled+size, all_elements));
+
+    std::random_shuffle(Iter(shuffled), Iter(shuffled+size));
+    assert(std::is_permutation(shuffled, shuffled+size, all_elements));
+}
+
 
 int main()
 {
-    int ia[] = {1, 2, 3, 4};
+    int ia[]  = {1, 2, 3, 4};
     int ia1[] = {1, 4, 3, 2};
     int ia2[] = {4, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
+
     std::random_shuffle(ia, ia+sa);
     LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
     assert(std::is_permutation(ia, ia+sa, ia1));
+
     std::random_shuffle(ia, ia+sa);
     LIBCPP_ASSERT(std::equal(ia, ia+sa, ia2));
     assert(std::is_permutation(ia, ia+sa, ia2));
+
+    test_with_iterator<random_access_iterator<int*> >();
+    test_with_iterator<int*>();
+
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
index 6cab25cc7..ffdb098fc 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
@@ -20,6 +20,8 @@
 #include <cstddef>
 
 #include "test_macros.h"
+#include "test_iterators.h"
+
 
 struct gen
 {
@@ -29,13 +31,28 @@ struct gen
     }
 };
 
-int main()
+
+template <class Iter>
+void
+test_with_iterator()
 {
+
     int ia[] = {1, 2, 3, 4};
     int ia1[] = {4, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     gen r;
+
     std::random_shuffle(ia, ia+sa, r);
     LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
     assert(std::is_permutation(ia, ia+sa, ia1));
+
+    std::random_shuffle(ia, ia+sa, r);
+    assert(std::is_permutation(ia, ia+sa, ia1));
 }
+
+
+int main()
+{
+    test_with_iterator<random_access_iterator<int*> >();
+    test_with_iterator<int*>();
+}
\ No newline at end of file
-- 
GitLab


From 9788355e303477b959b5d0f03058abde872743b2 Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Thu, 24 Jan 2019 20:26:02 +0000
Subject: [PATCH 083/137] Mark awk.pass.cpp as XFAIL for NetBSD

Reported on the NetBSD 8 build bot.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352097 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/std/re/re.alg/re.alg.match/awk.pass.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/std/re/re.alg/re.alg.match/awk.pass.cpp b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
index 4afc6b0ef..095980c60 100644
--- a/test/std/re/re.alg/re.alg.match/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
@@ -17,7 +17,8 @@
 //                                            = regex_constants::match_default);
 
 // TODO: investigation needed
-// XFAIL: linux-gnu
+// TODO(netbsd): incomplete support for locales
+// XFAIL: linux-gnu, netbsd
 
 #include <regex>
 #include <cassert>
-- 
GitLab


From 427fc9484cbaf0c6e9f2592666e3dc6767abb60b Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Mon, 28 Jan 2019 02:59:01 +0000
Subject: [PATCH 084/137] update upcoming meeting issue status

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352339 91177308-0d34-0410-b5e6-96231b3b80d8
---
 www/upcoming_meeting.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index 44db2c472..f99ff14dd 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -99,7 +99,7 @@
 <li>3077 - No changes required</li>
 <li>3087 - No changes required</li>
 <li>3101 - Patch: <a href="https://reviews.llvm.org/D57058">D57058</a></li>
-<li>3112 - Eric - can you take a look?</li>
+<li>3112 - Patch: <a href="https://reviews.llvm.org/D57312">D57312</a></li>
 <li>3119 - No changes required</li>
 <li>3133 - </li>
 <li>3144 - Patch: <a href="https://reviews.llvm.org/D57039">D57039</a></li>
-- 
GitLab


From e15f28cfcac344cd7d86a281f499d24ee7ae87bc Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Mon, 28 Jan 2019 04:12:54 +0000
Subject: [PATCH 085/137] [CMake] Use __libc_start_main rather than fopen when
 checking for C library

The check_library_exists CMake uses a custom symbol definition. This
is a problem when checking for C library symbols because Clang
recognizes many of them as builtins, and returns the
-Wbuiltin-requires-header (or -Wincompatible-library-redeclaration)
error. When building with -Werror which is the default, this causes
the check_library_exists check fail making the build think that C
library isn't available.

To avoid this issue, we should use a symbol that isn't recognized by
Clang and wouldn't cause the same issue. __libc_start_main seems like
reasonable choice that fits the bill.

Differential Revision: https://reviews.llvm.org/D57142

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352341 91177308-0d34-0410-b5e6-96231b3b80d8
---
 cmake/config-ix.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/config-ix.cmake b/cmake/config-ix.cmake
index 730ee7e16..657b036dc 100644
--- a/cmake/config-ix.cmake
+++ b/cmake/config-ix.cmake
@@ -7,7 +7,7 @@ if(WIN32 AND NOT MINGW)
   # let the default linking take care of that.
   set(LIBCXX_HAS_C_LIB NO)
 else()
-  check_library_exists(c fopen "" LIBCXX_HAS_C_LIB)
+  check_library_exists(c __libc_start_main "" LIBCXX_HAS_C_LIB)
 endif()
 
 if (NOT LIBCXX_USE_COMPILER_RT)
-- 
GitLab


From d9cf3925b1ea21f8f823038acd004424d0478808 Mon Sep 17 00:00:00 2001
From: Michal Gorny <mgorny@gentoo.org>
Date: Mon, 28 Jan 2019 15:16:03 +0000
Subject: [PATCH 086/137] [cmake] Fix get_llvm_lit_path() to respect
 LLVM_EXTERNAL_LIT always

Refactor the get_llvm_lit_path() logic to respect LLVM_EXTERNAL_LIT,
and require the fallback to be defined explicitly
as LLVM_DEFAULT_EXTERNAL_LIT. This fixes building libcxx standalone
after r346888.

The old logic was using LLVM_EXTERNAL_LIT both as user-defined cache
variable and an optional pre-definition of default value from caller
(e.g. libcxx). It included a hack to make this work by assigning
the value back and forth but it was fragile and stopped working
in libcxx.

The new logic is simpler and more transparent. Default value is
provided in a separate variable, and used only when user-specified
variable is empty (i.e. not overriden).

Differential Revision: https://reviews.llvm.org/D57282

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352374 91177308-0d34-0410-b5e6-96231b3b80d8
---
 cmake/Modules/HandleOutOfTreeLLVM.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/Modules/HandleOutOfTreeLLVM.cmake b/cmake/Modules/HandleOutOfTreeLLVM.cmake
index 70eed1d70..11c133155 100644
--- a/cmake/Modules/HandleOutOfTreeLLVM.cmake
+++ b/cmake/Modules/HandleOutOfTreeLLVM.cmake
@@ -116,7 +116,7 @@ macro(configure_out_of_tree_llvm)
     # Required LIT Configuration ------------------------------------------------
     # Define the default arguments to use with 'lit', and an option for the user
     # to override.
-    set(LLVM_EXTERNAL_LIT "${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py")
+    set(LLVM_DEFAULT_EXTERNAL_LIT "${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py")
     set(LIT_ARGS_DEFAULT "-sv --show-xfail --show-unsupported")
     if (MSVC OR XCODE)
       set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
-- 
GitLab


From 1d9cc94e8947f740404ca81a7038e487a9b8a20f Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Mon, 28 Jan 2019 19:26:41 +0000
Subject: [PATCH 087/137] Revert "[CMake] Use __libc_start_main rather than
 fopen when checking for C library"

This reverts commit r352341: it broke the build on macOS which doesn't
seem to provide __libc_start_main in its C library.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352411 91177308-0d34-0410-b5e6-96231b3b80d8
---
 cmake/config-ix.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/config-ix.cmake b/cmake/config-ix.cmake
index 657b036dc..730ee7e16 100644
--- a/cmake/config-ix.cmake
+++ b/cmake/config-ix.cmake
@@ -7,7 +7,7 @@ if(WIN32 AND NOT MINGW)
   # let the default linking take care of that.
   set(LIBCXX_HAS_C_LIB NO)
 else()
-  check_library_exists(c __libc_start_main "" LIBCXX_HAS_C_LIB)
+  check_library_exists(c fopen "" LIBCXX_HAS_C_LIB)
 endif()
 
 if (NOT LIBCXX_USE_COMPILER_RT)
-- 
GitLab


From 4267db0b265969d9b4638aea9b8034406bd1cd28 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Mon, 28 Jan 2019 20:39:50 +0000
Subject: [PATCH 088/137] [libc++] Use runtime rather then compile-time glibc
 version check

glibc supports versioning, so it's possible to build against older
version and run against newer version. This is sometimes relied on
in practice, e.g. in Fuchsia build we build against older sysroot
(equivalent to Ubuntu Trusty) to cover the broadest possible range
of host systems, but that doesn't necessarily match the system that
binary is going to run on which may have newer version, in which case
the compile test used in curr_symbol is going to fail. Using runtime
check is more reliable.

Differential Revision: https://reviews.llvm.org/D56702

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352425 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../curr_symbol.pass.cpp                      | 34 +++++++++++++------
 1 file changed, 24 insertions(+), 10 deletions(-)

diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
index f66d2c633..f04ff4fb6 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
@@ -61,6 +61,20 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
+#if defined(_CS_GNU_LIBC_VERSION)
+static bool glibc_version_less_than(char const* version) {
+    std::string test_version = std::string("glibc ") + version;
+
+    size_t n = confstr(_CS_GNU_LIBC_VERSION, nullptr, (size_t)0);
+    char *current_version = new char[n];
+    confstr(_CS_GNU_LIBC_VERSION, current_version, n);
+
+    bool result = strverscmp(current_version, test_version.c_str()) < 0;
+    delete[] current_version;
+    return result;
+}
+#endif
+
 int main()
 {
     {
@@ -116,17 +130,14 @@ int main()
 
     {
         Fnf f(LOCALE_ru_RU_UTF_8, 1);
+#if defined(_CS_GNU_LIBC_VERSION)
         // GLIBC <= 2.23 uses currency_symbol="<U0440><U0443><U0431>"
         // GLIBC >= 2.24 uses currency_symbol="<U20BD>"
         // See also: http://www.fileformat.info/info/unicode/char/20bd/index.htm
-#if defined(TEST_GLIBC_PREREQ)
-    #if TEST_GLIBC_PREREQ(2, 24)
-        #define TEST_GLIBC_2_24_CURRENCY_SYMBOL
-    #endif
-#endif
-
-#if defined(TEST_GLIBC_2_24_CURRENCY_SYMBOL)
-        assert(f.curr_symbol() == " \u20BD");
+        if (!glibc_version_less_than("2.24"))
+          assert(f.curr_symbol() == " \u20BD");
+        else
+          assert(f.curr_symbol() == " \xD1\x80\xD1\x83\xD0\xB1");
 #else
         assert(f.curr_symbol() == " \xD1\x80\xD1\x83\xD0\xB1");
 #endif
@@ -137,8 +148,11 @@ int main()
     }
     {
         Fwf f(LOCALE_ru_RU_UTF_8, 1);
-#if defined(TEST_GLIBC_2_24_CURRENCY_SYMBOL)
-        assert(f.curr_symbol() == L" \u20BD");
+#if defined(_CS_GNU_LIBC_VERSION)
+        if (!glibc_version_less_than("2.24"))
+          assert(f.curr_symbol() == L" \u20BD");
+        else
+          assert(f.curr_symbol() == L" \x440\x443\x431");
 #else
         assert(f.curr_symbol() == L" \x440\x443\x431");
 #endif
-- 
GitLab


From 92f58d1b3699e5a743b887fb0770fdbb3693be35 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Tue, 29 Jan 2019 16:12:45 +0000
Subject: [PATCH 089/137] Mark some of the behavior in the move w/allocator
 constructors of deque/unordered containers as 'libc++-specific'. Thanks to
 Andrey Maksimov for pointing this out.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352512 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../map/map.cons/move_alloc.pass.cpp          | 15 +++++------
 .../multimap.cons/move_alloc.pass.cpp         | 15 +++++------
 .../multiset.cons/move_alloc.pass.cpp         | 11 ++++----
 .../set/set.cons/move_alloc.pass.cpp          | 11 ++++----
 .../deque/deque.cons/move_alloc.pass.cpp      | 25 ++++++++++---------
 5 files changed, 41 insertions(+), 36 deletions(-)

diff --git a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
index 728f14c42..cec925356 100644
--- a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
@@ -17,6 +17,7 @@
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
@@ -62,7 +63,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(7));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -101,7 +102,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -140,7 +141,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef Counter<int> T;
@@ -176,14 +177,14 @@ int main()
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
-            assert(m1.empty());
+            LIBCPP_ASSERT(m1.empty());
             assert(Counter_base::gConstructed == num+6);
 
             {
             M m4(std::move(m2), A(5));
             assert(Counter_base::gConstructed == num+6);
             assert(m4 == m3);
-            assert(m2.empty());
+            LIBCPP_ASSERT(m2.empty());
             }
             assert(Counter_base::gConstructed == num+3);
         }
@@ -226,7 +227,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A());
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -265,6 +266,6 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A{});
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
index c01591658..3342a4eda 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
@@ -17,6 +17,7 @@
 #include <map>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
@@ -62,7 +63,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(7));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -101,7 +102,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -140,7 +141,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef Counter<int> T;
@@ -176,14 +177,14 @@ int main()
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
-            assert(m1.empty());
+            LIBCPP_ASSERT(m1.empty());
             assert(Counter_base::gConstructed == 3*num);
 
             {
             M m4(std::move(m2), A(5));
             assert(Counter_base::gConstructed == 3*num);
             assert(m4 == m3);
-            assert(m2.empty());
+            LIBCPP_ASSERT(m2.empty());
             }
             assert(Counter_base::gConstructed == 2*num);
         }
@@ -226,7 +227,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A());
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -265,6 +266,6 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A{});
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
index f8e12ddca..c91a97b49 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
@@ -17,6 +17,7 @@
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
@@ -60,7 +61,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(7));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef MoveOnly V;
@@ -98,7 +99,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef MoveOnly V;
@@ -136,7 +137,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef Counter<int> V;
@@ -170,14 +171,14 @@ int main()
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
-            assert(m1.empty());
+            LIBCPP_ASSERT(m1.empty());
             assert(Counter_base::gConstructed == 3*num);
 
             {
             M m4(std::move(m2), A(5));
             assert(Counter_base::gConstructed == 3*num);
             assert(m4 == m3);
-            assert(m2.empty());
+            LIBCPP_ASSERT(m2.empty());
             }
             assert(Counter_base::gConstructed == 2*num);
         }
diff --git a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
index 769023445..7bae3ed21 100644
--- a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
@@ -17,6 +17,7 @@
 #include <set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
@@ -60,7 +61,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(7));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef MoveOnly V;
@@ -98,7 +99,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef MoveOnly V;
@@ -136,7 +137,7 @@ int main()
         assert(m3 == m2);
         assert(m3.get_allocator() == A(5));
         assert(m3.key_comp() == C(5));
-        assert(m1.empty());
+        LIBCPP_ASSERT(m1.empty());
     }
     {
         typedef Counter<int> V;
@@ -170,14 +171,14 @@ int main()
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
-            assert(m1.empty());
+            LIBCPP_ASSERT(m1.empty());
             assert(Counter_base::gConstructed == 6+num);
 
             {
             M m4(std::move(m2), A(5));
             assert(Counter_base::gConstructed == 6+num);
             assert(m4 == m3);
-            assert(m2.empty());
+            LIBCPP_ASSERT(m2.empty());
             }
             assert(Counter_base::gConstructed == 3+num);
         }
diff --git a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
index 3d7af53c4..54ce39d7e 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
@@ -15,6 +15,7 @@
 #include <deque>
 #include <cassert>
 
+#include "test_macros.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
@@ -23,7 +24,7 @@ int main()
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
-        int* an = ab + sizeof(ab)/sizeof(ab[0]);
+        const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef test_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(1));
         for (int* p = ab; p < an; ++p)
@@ -31,14 +32,14 @@ int main()
         std::deque<MoveOnly, A> c2(A(1));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
-        std::deque<MoveOnly, A> c3(std::move(c1), A(3));
+        std::deque<MoveOnly, A> c3(std::move(c1), A(3)); // unequal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A(3));
-        assert(c1.size() != 0);
+        LIBCPP_ASSERT(c1.size() != 0);
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
-        int* an = ab + sizeof(ab)/sizeof(ab[0]);
+        const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef test_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(1));
         for (int* p = ab; p < an; ++p)
@@ -46,14 +47,14 @@ int main()
         std::deque<MoveOnly, A> c2(A(1));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
-        std::deque<MoveOnly, A> c3(std::move(c1), A(1));
+        std::deque<MoveOnly, A> c3(std::move(c1), A(1)); // equal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A(1));
-        assert(c1.size() == 0);
+        LIBCPP_ASSERT(c1.size() == 0);
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
-        int* an = ab + sizeof(ab)/sizeof(ab[0]);
+        const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef other_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A(1));
         for (int* p = ab; p < an; ++p)
@@ -61,14 +62,14 @@ int main()
         std::deque<MoveOnly, A> c2(A(1));
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
-        std::deque<MoveOnly, A> c3(std::move(c1), A(3));
+        std::deque<MoveOnly, A> c3(std::move(c1), A(3)); // unequal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A(3));
-        assert(c1.size() != 0);
+        LIBCPP_ASSERT(c1.size() != 0);
     }
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
-        int* an = ab + sizeof(ab)/sizeof(ab[0]);
+        const int* an = ab + sizeof(ab)/sizeof(ab[0]);
         typedef min_allocator<MoveOnly> A;
         std::deque<MoveOnly, A> c1(A{});
         for (int* p = ab; p < an; ++p)
@@ -76,9 +77,9 @@ int main()
         std::deque<MoveOnly, A> c2(A{});
         for (int* p = ab; p < an; ++p)
             c2.push_back(MoveOnly(*p));
-        std::deque<MoveOnly, A> c3(std::move(c1), A());
+        std::deque<MoveOnly, A> c3(std::move(c1), A());  // equal allocator
         assert(c2 == c3);
         assert(c3.get_allocator() == A());
-        assert(c1.size() == 0);
+        LIBCPP_ASSERT(c1.size() == 0);
     }
 }
-- 
GitLab


From b8bdc7a1574cbb5ba6ef9754e6b96bcf6d96b3dd Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 29 Jan 2019 16:30:11 +0000
Subject: [PATCH 090/137] [NFC] Add missing revision for removal of
 bad_array_length in ABI changelog

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352513 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/abi/CHANGELOG.TXT | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/abi/CHANGELOG.TXT b/lib/abi/CHANGELOG.TXT
index 38dffd290..95bdb714e 100644
--- a/lib/abi/CHANGELOG.TXT
+++ b/lib/abi/CHANGELOG.TXT
@@ -16,7 +16,7 @@ New entries should be added directly below the "Version" header.
 Version 8.0
 -----------
 
-* rXXXXX - Remove std::bad_array_length
+* r347903 - Remove std::bad_array_length
 
   The change removes the definition of std::bad_array_length (which never made
   it into the standard) from the headers and the dylib. This is technically an
-- 
GitLab


From e0324cb307cc5dd2974faa3e0f2d8693c0aec9a0 Mon Sep 17 00:00:00 2001
From: James Y Knight <jyknight@google.com>
Date: Tue, 29 Jan 2019 16:37:27 +0000
Subject: [PATCH 091/137] Adjust documentation for git migration.

This fixes most references to the paths:
 llvm.org/svn/
 llvm.org/git/
 llvm.org/viewvc/
 github.com/llvm-mirror/
 github.com/llvm-project/
 reviews.llvm.org/diffusion/

to instead point to https://github.com/llvm/llvm-project.

This is *not* a trivial substitution, because additionally, all the
checkout instructions had to be migrated to instruct users on how to
use the monorepo layout, setting LLVM_ENABLE_PROJECTS instead of
checking out various projects into various subdirectories.

I've attempted to not change any scripts here, only documentation. The
scripts will have to be addressed separately.

Additionally, I've deleted one document which appeared to be outdated
and unneeded:
  lldb/docs/building-with-debug-llvm.txt

Differential Revision: https://reviews.llvm.org/D57330

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352514 91177308-0d34-0410-b5e6-96231b3b80d8
---
 docs/BuildingLibcxx.rst     | 47 +++++++++----------------------------
 docs/index.rst              |  3 +--
 www/TS_deprecation.html     |  3 +--
 www/atomic_design.html      |  3 +--
 www/atomic_design_a.html    |  3 +--
 www/atomic_design_b.html    |  3 +--
 www/atomic_design_c.html    |  3 +--
 www/cxx1y_status.html       |  3 +--
 www/cxx1z_status.html       |  3 +--
 www/cxx2a_status.html       |  3 +--
 www/index.html              |  3 +--
 www/ts1z_status.html        |  3 +--
 www/type_traits_design.html |  3 +--
 www/upcoming_meeting.html   |  3 +--
 14 files changed, 24 insertions(+), 62 deletions(-)

diff --git a/docs/BuildingLibcxx.rst b/docs/BuildingLibcxx.rst
index a498c0027..01f442de3 100644
--- a/docs/BuildingLibcxx.rst
+++ b/docs/BuildingLibcxx.rst
@@ -18,33 +18,10 @@ Xcode 4.2 or later.  However if you want to install tip-of-trunk from here
 
 The basic steps needed to build libc++ are:
 
-#. Checkout LLVM:
-
-   * ``cd where-you-want-llvm-to-live``
-   * ``svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm``
-
-#. Checkout libc++:
-
-   * ``cd where-you-want-llvm-to-live``
-   * ``cd llvm/projects``
-   * ``svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx``
-
-#. Checkout libc++abi:
-
-   * ``cd where-you-want-llvm-to-live``
-   * ``cd llvm/projects``
-   * ``svn co http://llvm.org/svn/llvm-project/libcxxabi/trunk libcxxabi``
-
-#. Configure and build libc++ with libc++abi:
-
-   CMake is the only supported configuration system.
-
-   Clang is the preferred compiler when building and using libc++.
-
-   * ``cd where you want to build llvm``
-   * ``mkdir build``
-   * ``cd build``
-   * ``cmake -G <generator> [options] <path to llvm sources>``
+#. Checkout and configure LLVM (including libc++ and libc++abi), according to the `LLVM
+   getting started <https://llvm.org/docs/GettingStarted.html>`_ documentation. Make sure
+   to include ``libcxx`` and ``libcxxabi`` in the ``LLVM_ENABLE_PROJECTS`` option passed
+   to CMake.
 
    For more information about configuring libc++ see :ref:`CMake Options`.
 
@@ -71,23 +48,21 @@ The instructions are for building libc++ on
 FreeBSD, Linux, or Mac using `libc++abi`_ as the C++ ABI library.
 On Linux, it is also possible to use :ref:`libsupc++ <libsupcxx>` or libcxxrt.
 
-It is sometimes beneficial to build outside of the LLVM tree. An out-of-tree
-build would look like this:
+It is sometimes beneficial to build separately from the full LLVM build. An
+out-of-tree build would look like this:
 
 .. code-block:: bash
 
   $ cd where-you-want-libcxx-to-live
-  $ # Check out llvm, libc++ and libc++abi.
-  $ ``svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm``
-  $ ``svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx``
-  $ ``svn co http://llvm.org/svn/llvm-project/libcxxabi/trunk libcxxabi``
+  $ # Check out the sources (includes everything, but we'll only use libcxx)
+  $ ``git clone https://github.com/llvm/llvm-project.git``
   $ cd where-you-want-to-build
   $ mkdir build && cd build
   $ export CC=clang CXX=clang++
-  $ cmake -DLLVM_PATH=path/to/llvm \
+  $ cmake -DLLVM_PATH=path/to/separate/llvm \
           -DLIBCXX_CXX_ABI=libcxxabi \
-          -DLIBCXX_CXX_ABI_INCLUDE_PATHS=path/to/libcxxabi/include \
-          path/to/libcxx
+          -DLIBCXX_CXX_ABI_INCLUDE_PATHS=path/to/separate/libcxxabi/include \
+          path/to/llvm-project/libcxx
   $ make
   $ make check-libcxx # optional
 
diff --git a/docs/index.rst b/docs/index.rst
index fddf74b66..80c2a8ddd 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -190,5 +190,4 @@ Quick Links
 * `LLVM Bugzilla <https://bugs.llvm.org/>`_
 * `libcxx-commits Mailing List`_
 * `libcxx-dev Mailing List`_
-* `Browse libc++ -- SVN <http://llvm.org/svn/llvm-project/libcxx/trunk/>`_
-* `Browse libc++ -- ViewVC <http://llvm.org/viewvc/llvm-project/libcxx/trunk/>`_
+* `Browse libc++ Sources <https://github.com/llvm/llvm-project/tree/master/libcxx/>`_
diff --git a/www/TS_deprecation.html b/www/TS_deprecation.html
index a8dd8c183..f3c002fe4 100644
--- a/www/TS_deprecation.html
+++ b/www/TS_deprecation.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/atomic_design.html b/www/atomic_design.html
index 1c6627aad..30fb6feeb 100644
--- a/www/atomic_design.html
+++ b/www/atomic_design.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/atomic_design_a.html b/www/atomic_design_a.html
index 589ca83c1..d3e687f0d 100644
--- a/www/atomic_design_a.html
+++ b/www/atomic_design_a.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/atomic_design_b.html b/www/atomic_design_b.html
index 7f81f8b7c..e07eb8698 100644
--- a/www/atomic_design_b.html
+++ b/www/atomic_design_b.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/atomic_design_c.html b/www/atomic_design_c.html
index 82cc80f7f..936ee6588 100644
--- a/www/atomic_design_c.html
+++ b/www/atomic_design_c.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/cxx1y_status.html b/www/cxx1y_status.html
index 0af6352e9..7c62dc5ec 100644
--- a/www/cxx1y_status.html
+++ b/www/cxx1y_status.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/cxx1z_status.html b/www/cxx1z_status.html
index c2c6f7b02..823c37b58 100644
--- a/www/cxx1z_status.html
+++ b/www/cxx1z_status.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index a5e87ec18..36bc659c9 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/index.html b/www/index.html
index 3724b8b43..c707bc18b 100644
--- a/www/index.html
+++ b/www/index.html
@@ -26,8 +26,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/libcxx-dev">libcxx-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/libcxx-commits">libcxx-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/ts1z_status.html b/www/ts1z_status.html
index 22ad0d450..1c2e3a244 100644
--- a/www/ts1z_status.html
+++ b/www/ts1z_status.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/type_traits_design.html b/www/type_traits_design.html
index 1cab2936d..3b3355f2f 100644
--- a/www/type_traits_design.html
+++ b/www/type_traits_design.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index f99ff14dd..801a92b22 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -25,8 +25,7 @@
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
   </div>
 </div>
 
-- 
GitLab


From a32a775e66e7141185ef83ca225cbc4799cb70bf Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Tue, 29 Jan 2019 18:01:14 +0000
Subject: [PATCH 092/137] Fix PR40495 - is_invokable_v<void> does not compile

The meta-programming that attempted to form the invoke call expression
was not in a SFINAE context. This made it a hard error to provide
non-referencable types like 'void' or 'void (...) const'.

This patch fixes the error by checking the validity of the call
expression within a SFINAE context.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352522 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/type_traits                           |  37 ++-
 .../meta/meta.rel/is_invocable.pass.cpp       | 305 +++++++++++-------
 .../meta.rel/is_nothrow_invocable.pass.cpp    | 233 +++++++++----
 3 files changed, 376 insertions(+), 199 deletions(-)

diff --git a/include/type_traits b/include/type_traits
index 52a46adc5..37b7ca1a3 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -4360,28 +4360,31 @@ _LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...)
 #undef _LIBCPP_INVOKE_RETURN
 
 // __invokable
-
 template <class _Ret, class _Fp, class ..._Args>
 struct __invokable_r
 {
-    // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
-    // or incomplete array types as required by the standard.
-    using _Result = decltype(
-        _VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...));
+  template <class _XFp, class ..._XArgs>
+  static auto __try_call(int) -> decltype(
+    _VSTD::__invoke(_VSTD::declval<_XFp>(), _VSTD::declval<_XArgs>()...));
+  template <class _XFp, class ..._XArgs>
+  static __nat __try_call(...);
 
-    using type =
-        typename conditional<
-            !is_same<_Result, __nat>::value,
-            typename conditional<
-                is_void<_Ret>::value,
-                true_type,
-                is_convertible<_Result, _Ret>
-            >::type,
-            false_type
-        >::type;
-    static const bool value = type::value;
-};
+  // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
+  // or incomplete array types as required by the standard.
+  using _Result = decltype(__try_call<_Fp, _Args...>(0));
 
+  using type =
+  typename conditional<
+      !is_same<_Result, __nat>::value,
+      typename conditional<
+          is_void<_Ret>::value,
+          true_type,
+          is_convertible<_Result, _Ret>
+      >::type,
+      false_type
+  >::type;
+  static const bool value = type::value;
+};
 template <class _Fp, class ..._Args>
 using __invokable = __invokable_r<void, _Fp, _Args...>;
 
diff --git a/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
index a2dc09072..dab17974b 100644
--- a/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
@@ -15,9 +15,13 @@
 // Most testing of is_invocable is done within the [meta.trans.other] result_of
 // tests.
 
+// Fn and all types in the template parameter pack ArgTypes shall be
+//  complete types, cv void, or arrays of unknown bound.
+
 #include <type_traits>
 #include <functional>
 #include <memory>
+#include <vector>
 
 #include "test_macros.h"
 
@@ -37,129 +41,204 @@ struct NotCallableWithInt {
   int operator()(Tag) { return 42; }
 };
 
-int main()
-{
+struct Sink {
+  template <class ...Args>
+  void operator()(Args&&...) const {}
+};
+
+int main() {
+  using AbominableFunc = void(...) const;
+
+  //  Non-callable things
+  {
+    static_assert(!std::is_invocable<void>::value, "");
+    static_assert(!std::is_invocable<const void>::value, "");
+    static_assert(!std::is_invocable<volatile void>::value, "");
+    static_assert(!std::is_invocable<const volatile void>::value, "");
+    static_assert(!std::is_invocable<std::nullptr_t>::value, "");
+    static_assert(!std::is_invocable<int>::value, "");
+    static_assert(!std::is_invocable<double>::value, "");
+
+    static_assert(!std::is_invocable<int[]>::value, "");
+    static_assert(!std::is_invocable<int[3]>::value, "");
+
+    static_assert(!std::is_invocable<int*>::value, "");
+    static_assert(!std::is_invocable<const int*>::value, "");
+    static_assert(!std::is_invocable<int const*>::value, "");
+
+    static_assert(!std::is_invocable<int&>::value, "");
+    static_assert(!std::is_invocable<const int&>::value, "");
+    static_assert(!std::is_invocable<int&&>::value, "");
+
+    static_assert(!std::is_invocable<std::vector<int> >::value, "");
+    static_assert(!std::is_invocable<std::vector<int*> >::value, "");
+    static_assert(!std::is_invocable<std::vector<int**> >::value, "");
+
+    static_assert(!std::is_invocable<AbominableFunc>::value, "");
+
+    //  with parameters
+    static_assert(!std::is_invocable<int, int>::value, "");
+    static_assert(!std::is_invocable<int, double, float>::value, "");
+    static_assert(!std::is_invocable<int, char, float, double>::value, "");
+    static_assert(!std::is_invocable<Sink, AbominableFunc>::value, "");
+    static_assert(!std::is_invocable<Sink, void>::value, "");
+    static_assert(!std::is_invocable<Sink, const volatile void>::value,
+                  "");
+
+
+    static_assert(!std::is_invocable_r<int, void>::value, "");
+    static_assert(!std::is_invocable_r<int, const void>::value, "");
+    static_assert(!std::is_invocable_r<int, volatile void>::value, "");
+    static_assert(!std::is_invocable_r<int, const volatile void>::value, "");
+    static_assert(!std::is_invocable_r<int, std::nullptr_t>::value, "");
+    static_assert(!std::is_invocable_r<int, int>::value, "");
+    static_assert(!std::is_invocable_r<int, double>::value, "");
+
+    static_assert(!std::is_invocable_r<int, int[]>::value, "");
+    static_assert(!std::is_invocable_r<int, int[3]>::value, "");
+
+    static_assert(!std::is_invocable_r<int, int*>::value, "");
+    static_assert(!std::is_invocable_r<int, const int*>::value, "");
+    static_assert(!std::is_invocable_r<int, int const*>::value, "");
+
+    static_assert(!std::is_invocable_r<int, int&>::value, "");
+    static_assert(!std::is_invocable_r<int, const int&>::value, "");
+    static_assert(!std::is_invocable_r<int, int&&>::value, "");
+
+    static_assert(!std::is_invocable_r<int, std::vector<int> >::value, "");
+    static_assert(!std::is_invocable_r<int, std::vector<int*> >::value, "");
+    static_assert(!std::is_invocable_r<int, std::vector<int**> >::value, "");
+    static_assert(!std::is_invocable_r<void, AbominableFunc>::value, "");
+
+    //  with parameters
+    static_assert(!std::is_invocable_r<int, int, int>::value, "");
+    static_assert(!std::is_invocable_r<int, int, double, float>::value, "");
+    static_assert(!std::is_invocable_r<int, int, char, float, double>::value,
+                  "");
+    static_assert(!std::is_invocable_r<void, Sink, AbominableFunc>::value, "");
+    static_assert(!std::is_invocable_r<void, Sink, void>::value, "");
+    static_assert(!std::is_invocable_r<void, Sink, const volatile void>::value,
+                  "");
+  }
+  {
+    using Fn = int (Tag::*)(int);
+    using RFn = int (Tag::*)(int)&&;
+    // INVOKE bullet 1, 2 and 3
     {
-        using Fn = int(Tag::*)(int);
-        using RFn = int(Tag::*)(int) &&;
-        // INVOKE bullet 1, 2 and 3
-        {
-            // Bullet 1
-            static_assert(std::is_invocable<Fn, Tag&, int>::value, "");
-            static_assert(std::is_invocable<Fn, DerFromTag&, int>::value, "");
-            static_assert(std::is_invocable<RFn, Tag&&, int>::value, "");
-            static_assert(!std::is_invocable<RFn, Tag&, int>::value, "");
-            static_assert(!std::is_invocable<Fn, Tag&>::value, "");
-            static_assert(!std::is_invocable<Fn, Tag const&, int>::value, "");
-        }
-        {
-            // Bullet 2
-            using T = std::reference_wrapper<Tag>;
-            using DT = std::reference_wrapper<DerFromTag>;
-            using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_invocable<Fn, T&, int>::value, "");
-            static_assert(std::is_invocable<Fn, DT&, int>::value, "");
-            static_assert(std::is_invocable<Fn, const T&, int>::value, "");
-            static_assert(std::is_invocable<Fn, T&&, int>::value, "");
-            static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
-            static_assert(!std::is_invocable<RFn, T, int>::value, "");
-        }
-        {
-            // Bullet 3
-            using T = Tag*;
-            using DT = DerFromTag*;
-            using CT = const Tag*;
-            using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_invocable<Fn, T&, int>::value, "");
-            static_assert(std::is_invocable<Fn, DT&, int>::value, "");
-            static_assert(std::is_invocable<Fn, const T&, int>::value, "");
-            static_assert(std::is_invocable<Fn, T&&, int>::value, "");
-            static_assert(std::is_invocable<Fn, ST, int>::value, "");
-            static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
-            static_assert(!std::is_invocable<RFn, T, int>::value, "");
-        }
+      // Bullet 1
+      static_assert(std::is_invocable<Fn, Tag&, int>::value, "");
+      static_assert(std::is_invocable<Fn, DerFromTag&, int>::value, "");
+      static_assert(std::is_invocable<RFn, Tag&&, int>::value, "");
+      static_assert(!std::is_invocable<RFn, Tag&, int>::value, "");
+      static_assert(!std::is_invocable<Fn, Tag&>::value, "");
+      static_assert(!std::is_invocable<Fn, Tag const&, int>::value, "");
     }
     {
-        // Bullets 4, 5 and 6
-        using Fn = int (Tag::*);
-        static_assert(!std::is_invocable<Fn>::value, "");
-        {
-            // Bullet 4
-            static_assert(std::is_invocable<Fn, Tag&>::value, "");
-            static_assert(std::is_invocable<Fn, DerFromTag&>::value, "");
-            static_assert(std::is_invocable<Fn, Tag&&>::value, "");
-            static_assert(std::is_invocable<Fn, Tag const&>::value, "");
-        }
-        {
-            // Bullet 5
-            using T = std::reference_wrapper<Tag>;
-            using DT = std::reference_wrapper<DerFromTag>;
-            using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_invocable<Fn, T&>::value, "");
-            static_assert(std::is_invocable<Fn, DT&>::value, "");
-            static_assert(std::is_invocable<Fn, const T&>::value, "");
-            static_assert(std::is_invocable<Fn, T&&>::value, "");
-            static_assert(std::is_invocable<Fn, CT&>::value, "");
-        }
-        {
-            // Bullet 6
-            using T = Tag*;
-            using DT = DerFromTag*;
-            using CT = const Tag*;
-            using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_invocable<Fn, T&>::value, "");
-            static_assert(std::is_invocable<Fn, DT&>::value, "");
-            static_assert(std::is_invocable<Fn, const T&>::value, "");
-            static_assert(std::is_invocable<Fn, T&&>::value, "");
-            static_assert(std::is_invocable<Fn, ST>::value, "");
-            static_assert(std::is_invocable<Fn, CT&>::value, "");
-        }
+      // Bullet 2
+      using T = std::reference_wrapper<Tag>;
+      using DT = std::reference_wrapper<DerFromTag>;
+      using CT = std::reference_wrapper<const Tag>;
+      static_assert(std::is_invocable<Fn, T&, int>::value, "");
+      static_assert(std::is_invocable<Fn, DT&, int>::value, "");
+      static_assert(std::is_invocable<Fn, const T&, int>::value, "");
+      static_assert(std::is_invocable<Fn, T&&, int>::value, "");
+      static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
+      static_assert(!std::is_invocable<RFn, T, int>::value, "");
     }
     {
-        // INVOKE bullet 7
-        {
-            // Function pointer
-            using Fp = void(*)(Tag&, int);
-            static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
-            static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
-            static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
-            static_assert(!std::is_invocable<Fp>::value, "");
-            static_assert(!std::is_invocable<Fp, Tag&>::value, "");
-        }
-        {
-            // Function reference
-            using Fp = void(&)(Tag&, int);
-            static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
-            static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
-            static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
-            static_assert(!std::is_invocable<Fp>::value, "");
-            static_assert(!std::is_invocable<Fp, Tag&>::value, "");
-        }
-        {
-            // Function object
-            using Fn = NotCallableWithInt;
-            static_assert(std::is_invocable<Fn, Tag>::value, "");
-            static_assert(!std::is_invocable<Fn, int>::value, "");
-        }
+      // Bullet 3
+      using T = Tag*;
+      using DT = DerFromTag*;
+      using CT = const Tag*;
+      using ST = std::unique_ptr<Tag>;
+      static_assert(std::is_invocable<Fn, T&, int>::value, "");
+      static_assert(std::is_invocable<Fn, DT&, int>::value, "");
+      static_assert(std::is_invocable<Fn, const T&, int>::value, "");
+      static_assert(std::is_invocable<Fn, T&&, int>::value, "");
+      static_assert(std::is_invocable<Fn, ST, int>::value, "");
+      static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
+      static_assert(!std::is_invocable<RFn, T, int>::value, "");
     }
+  }
+  {
+    // Bullets 4, 5 and 6
+    using Fn = int(Tag::*);
+    static_assert(!std::is_invocable<Fn>::value, "");
     {
-        // Check that the conversion to the return type is properly checked
-        using Fn = int(*)();
-        static_assert(std::is_invocable_r<Implicit, Fn>::value, "");
-        static_assert(std::is_invocable_r<double, Fn>::value, "");
-        static_assert(std::is_invocable_r<const volatile void, Fn>::value, "");
-        static_assert(!std::is_invocable_r<Explicit, Fn>::value, "");
+      // Bullet 4
+      static_assert(std::is_invocable<Fn, Tag&>::value, "");
+      static_assert(std::is_invocable<Fn, DerFromTag&>::value, "");
+      static_assert(std::is_invocable<Fn, Tag&&>::value, "");
+      static_assert(std::is_invocable<Fn, Tag const&>::value, "");
     }
     {
-        // Check for is_invocable_v
-        using Fn = void(*)();
-        static_assert(std::is_invocable_v<Fn>, "");
-        static_assert(!std::is_invocable_v<Fn, int>, "");
+      // Bullet 5
+      using T = std::reference_wrapper<Tag>;
+      using DT = std::reference_wrapper<DerFromTag>;
+      using CT = std::reference_wrapper<const Tag>;
+      static_assert(std::is_invocable<Fn, T&>::value, "");
+      static_assert(std::is_invocable<Fn, DT&>::value, "");
+      static_assert(std::is_invocable<Fn, const T&>::value, "");
+      static_assert(std::is_invocable<Fn, T&&>::value, "");
+      static_assert(std::is_invocable<Fn, CT&>::value, "");
     }
     {
-        // Check for is_invocable_r_v
-        using Fn = void(*)();
-        static_assert(std::is_invocable_r_v<void, Fn>, "");
-        static_assert(!std::is_invocable_r_v<int, Fn>, "");
+      // Bullet 6
+      using T = Tag*;
+      using DT = DerFromTag*;
+      using CT = const Tag*;
+      using ST = std::unique_ptr<Tag>;
+      static_assert(std::is_invocable<Fn, T&>::value, "");
+      static_assert(std::is_invocable<Fn, DT&>::value, "");
+      static_assert(std::is_invocable<Fn, const T&>::value, "");
+      static_assert(std::is_invocable<Fn, T&&>::value, "");
+      static_assert(std::is_invocable<Fn, ST>::value, "");
+      static_assert(std::is_invocable<Fn, CT&>::value, "");
     }
+  }
+  { // INVOKE bullet 7
+   {// Function pointer
+    using Fp = void(*)(Tag&, int);
+  static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
+  static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
+  static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
+  static_assert(!std::is_invocable<Fp>::value, "");
+  static_assert(!std::is_invocable<Fp, Tag&>::value, "");
+}
+{
+  // Function reference
+  using Fp = void (&)(Tag&, int);
+  static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
+  static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
+  static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
+  static_assert(!std::is_invocable<Fp>::value, "");
+  static_assert(!std::is_invocable<Fp, Tag&>::value, "");
+}
+{
+  // Function object
+  using Fn = NotCallableWithInt;
+  static_assert(std::is_invocable<Fn, Tag>::value, "");
+  static_assert(!std::is_invocable<Fn, int>::value, "");
+}
+}
+{
+  // Check that the conversion to the return type is properly checked
+  using Fn = int (*)();
+  static_assert(std::is_invocable_r<Implicit, Fn>::value, "");
+  static_assert(std::is_invocable_r<double, Fn>::value, "");
+  static_assert(std::is_invocable_r<const volatile void, Fn>::value, "");
+  static_assert(!std::is_invocable_r<Explicit, Fn>::value, "");
+}
+{
+  // Check for is_invocable_v
+  using Fn = void (*)();
+  static_assert(std::is_invocable_v<Fn>, "");
+  static_assert(!std::is_invocable_v<Fn, int>, "");
+}
+{
+  // Check for is_invocable_r_v
+  using Fn = void (*)();
+  static_assert(std::is_invocable_r_v<void, Fn>, "");
+  static_assert(!std::is_invocable_r_v<int, Fn>, "");
+}
 }
diff --git a/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
index e4ce36b50..f21e99b02 100644
--- a/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
@@ -14,6 +14,7 @@
 
 #include <type_traits>
 #include <functional>
+#include <vector>
 
 #include "test_macros.h"
 
@@ -31,90 +32,184 @@ struct Explicit {
   explicit Explicit(int) noexcept {}
 };
 
-template <bool IsNoexcept, class Ret, class ...Args>
+template <bool IsNoexcept, class Ret, class... Args>
 struct CallObject {
   Ret operator()(Args&&...) const noexcept(IsNoexcept);
 };
 
-template <class Fn, class ...Args>
+struct Sink {
+  template <class... Args>
+  void operator()(Args&&...) const noexcept {}
+};
+
+template <class Fn, class... Args>
 constexpr bool throws_invocable() {
-    return std::is_invocable<Fn, Args...>::value &&
-        !std::is_nothrow_invocable<Fn, Args...>::value;
+  return std::is_invocable<Fn, Args...>::value &&
+         !std::is_nothrow_invocable<Fn, Args...>::value;
 }
 
-template <class Ret, class Fn, class ...Args>
+template <class Ret, class Fn, class... Args>
 constexpr bool throws_invocable_r() {
-    return std::is_invocable_r<Ret, Fn, Args...>::value &&
-        !std::is_nothrow_invocable_r<Ret, Fn, Args...>::value;
+  return std::is_invocable_r<Ret, Fn, Args...>::value &&
+         !std::is_nothrow_invocable_r<Ret, Fn, Args...>::value;
 }
 
 // FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
 // once implementations have caught up.
-void test_noexcept_function_pointers()
-{
-    struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
+void test_noexcept_function_pointers() {
+  struct Dummy {
+    void foo() noexcept {}
+    static void bar() noexcept {}
+  };
 #if !defined(__cpp_noexcept_function_type)
-    {
-        // Check that PMF's and function pointers *work*. is_nothrow_invocable will always
-        // return false because 'noexcept' is not part of the function type.
-        static_assert(throws_invocable<decltype(&Dummy::foo), Dummy&>(), "");
-        static_assert(throws_invocable<decltype(&Dummy::bar)>(), "");
-    }
+  {
+    // Check that PMF's and function pointers *work*. is_nothrow_invocable will always
+    // return false because 'noexcept' is not part of the function type.
+    static_assert(throws_invocable<decltype(&Dummy::foo), Dummy&>(), "");
+    static_assert(throws_invocable<decltype(&Dummy::bar)>(), "");
+  }
 #else
-    {
-        // Check that PMF's and function pointers actually work and that
-        // is_nothrow_invocable returns true for noexcept PMF's and function
-        // pointers.
-        static_assert(std::is_nothrow_invocable<decltype(&Dummy::foo), Dummy&>::value, "");
-        static_assert(std::is_nothrow_invocable<decltype(&Dummy::bar)>::value, "");
-    }
+  {
+    // Check that PMF's and function pointers actually work and that
+    // is_nothrow_invocable returns true for noexcept PMF's and function
+    // pointers.
+    static_assert(
+        std::is_nothrow_invocable<decltype(&Dummy::foo), Dummy&>::value, "");
+    static_assert(std::is_nothrow_invocable<decltype(&Dummy::bar)>::value, "");
+  }
 #endif
 }
 
-int main()
-{
-    {
-        // Check that the conversion to the return type is properly checked
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_invocable_r<Implicit, Fn>::value, "");
-        static_assert(std::is_nothrow_invocable_r<double, Fn>::value, "");
-        static_assert(std::is_nothrow_invocable_r<const volatile void, Fn>::value, "");
-        static_assert(throws_invocable_r<ThrowsImplicit, Fn>(), "");
-        static_assert(!std::is_nothrow_invocable<Fn(), Explicit>(), "");
-    }
-    {
-        // Check that the conversion to the parameters is properly checked
-        using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
-        static_assert(std::is_nothrow_invocable<Fn, Implicit&, ThrowsImplicit&>::value, "");
-        static_assert(std::is_nothrow_invocable<Fn, int, ThrowsImplicit&>::value, "");
-        static_assert(throws_invocable<Fn, int, int>(), "");
-        static_assert(!std::is_nothrow_invocable<Fn>::value, "");
-    }
-    {
-        // Check that the noexcept-ness of function objects is checked.
-        using Fn = CallObject<true, void>;
-        using Fn2 = CallObject<false, void>;
-        static_assert(std::is_nothrow_invocable<Fn>::value, "");
-        static_assert(throws_invocable<Fn2>(), "");
-    }
-    {
-        // Check that PMD derefs are noexcept
-        using Fn = int (Tag::*);
-        static_assert(std::is_nothrow_invocable<Fn, Tag&>::value, "");
-        static_assert(std::is_nothrow_invocable_r<Implicit, Fn, Tag&>::value, "");
-        static_assert(throws_invocable_r<ThrowsImplicit, Fn, Tag&>(), "");
-    }
-    {
-        // Check for is_nothrow_invocable_v
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_invocable_v<Fn>, "");
-        static_assert(!std::is_nothrow_invocable_v<Fn, int>, "");
-    }
-    {
-        // Check for is_nothrow_invocable_r_v
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_invocable_r_v<void, Fn>, "");
-        static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
-    }
-    test_noexcept_function_pointers();
+int main() {
+  using AbominableFunc = void(...) const noexcept;
+  //  Non-callable things
+  {
+    static_assert(!std::is_nothrow_invocable<void>::value, "");
+    static_assert(!std::is_nothrow_invocable<const void>::value, "");
+    static_assert(!std::is_nothrow_invocable<volatile void>::value, "");
+    static_assert(!std::is_nothrow_invocable<const volatile void>::value, "");
+    static_assert(!std::is_nothrow_invocable<std::nullptr_t>::value, "");
+    static_assert(!std::is_nothrow_invocable<int>::value, "");
+    static_assert(!std::is_nothrow_invocable<double>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int[]>::value, "");
+    static_assert(!std::is_nothrow_invocable<int[3]>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int*>::value, "");
+    static_assert(!std::is_nothrow_invocable<const int*>::value, "");
+    static_assert(!std::is_nothrow_invocable<int const*>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int&>::value, "");
+    static_assert(!std::is_nothrow_invocable<const int&>::value, "");
+    static_assert(!std::is_nothrow_invocable<int&&>::value, "");
+
+    static_assert(!std::is_nothrow_invocable<int, std::vector<int> >::value,
+                  "");
+    static_assert(!std::is_nothrow_invocable<int, std::vector<int*> >::value,
+                  "");
+    static_assert(!std::is_nothrow_invocable<int, std::vector<int**> >::value,
+                  "");
+
+    static_assert(!std::is_nothrow_invocable<AbominableFunc>::value, "");
+
+    //  with parameters
+    static_assert(!std::is_nothrow_invocable<int, int>::value, "");
+    static_assert(!std::is_nothrow_invocable<int, double, float>::value, "");
+    static_assert(!std::is_nothrow_invocable<int, char, float, double>::value,
+                  "");
+    static_assert(!std::is_nothrow_invocable<Sink, AbominableFunc>::value, "");
+    static_assert(!std::is_nothrow_invocable<Sink, void>::value, "");
+    static_assert(!std::is_nothrow_invocable<Sink, const volatile void>::value,
+                  "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, void>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const void>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, volatile void>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const volatile void>::value,
+                  "");
+    static_assert(!std::is_nothrow_invocable_r<int, std::nullptr_t>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, double>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, int[]>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int[3]>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, int*>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const int*>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int const*>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, int&>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, const int&>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int&&>::value, "");
+
+    static_assert(!std::is_nothrow_invocable_r<int, std::vector<int> >::value,
+                  "");
+    static_assert(!std::is_nothrow_invocable_r<int, std::vector<int*> >::value,
+                  "");
+    static_assert(!std::is_nothrow_invocable_r<int, std::vector<int**> >::value,
+                  "");
+    static_assert(!std::is_nothrow_invocable_r<void, AbominableFunc>::value,
+                  "");
+
+    //  with parameters
+    static_assert(!std::is_nothrow_invocable_r<int, int, int>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<int, int, double, float>::value,
+                  "");
+    static_assert(
+        !std::is_nothrow_invocable_r<int, int, char, float, double>::value, "");
+    static_assert(
+        !std::is_nothrow_invocable_r<void, Sink, AbominableFunc>::value, "");
+    static_assert(!std::is_nothrow_invocable_r<void, Sink, void>::value, "");
+    static_assert(
+        !std::is_nothrow_invocable_r<void, Sink, const volatile void>::value,
+        "");
+  }
+
+  {
+    // Check that the conversion to the return type is properly checked
+    using Fn = CallObject<true, int>;
+    static_assert(std::is_nothrow_invocable_r<Implicit, Fn>::value, "");
+    static_assert(std::is_nothrow_invocable_r<double, Fn>::value, "");
+    static_assert(std::is_nothrow_invocable_r<const volatile void, Fn>::value,
+                  "");
+    static_assert(throws_invocable_r<ThrowsImplicit, Fn>(), "");
+    static_assert(!std::is_nothrow_invocable<Fn(), Explicit>(), "");
+  }
+  {
+    // Check that the conversion to the parameters is properly checked
+    using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
+    static_assert(
+        std::is_nothrow_invocable<Fn, Implicit&, ThrowsImplicit&>::value, "");
+    static_assert(std::is_nothrow_invocable<Fn, int, ThrowsImplicit&>::value,
+                  "");
+    static_assert(throws_invocable<Fn, int, int>(), "");
+    static_assert(!std::is_nothrow_invocable<Fn>::value, "");
+  }
+  {
+    // Check that the noexcept-ness of function objects is checked.
+    using Fn = CallObject<true, void>;
+    using Fn2 = CallObject<false, void>;
+    static_assert(std::is_nothrow_invocable<Fn>::value, "");
+    static_assert(throws_invocable<Fn2>(), "");
+  }
+  {
+    // Check that PMD derefs are noexcept
+    using Fn = int(Tag::*);
+    static_assert(std::is_nothrow_invocable<Fn, Tag&>::value, "");
+    static_assert(std::is_nothrow_invocable_r<Implicit, Fn, Tag&>::value, "");
+    static_assert(throws_invocable_r<ThrowsImplicit, Fn, Tag&>(), "");
+  }
+  {
+    // Check for is_nothrow_invocable_v
+    using Fn = CallObject<true, int>;
+    static_assert(std::is_nothrow_invocable_v<Fn>, "");
+    static_assert(!std::is_nothrow_invocable_v<Fn, int>, "");
+  }
+  {
+    // Check for is_nothrow_invocable_r_v
+    using Fn = CallObject<true, int>;
+    static_assert(std::is_nothrow_invocable_r_v<void, Fn>, "");
+    static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
+  }
+  test_noexcept_function_pointers();
 }
-- 
GitLab


From 867782985a2bba83e4e4bce20166904d3813dabf Mon Sep 17 00:00:00 2001
From: Thomas Anderson <thomasanderson@google.com>
Date: Tue, 29 Jan 2019 18:48:35 +0000
Subject: [PATCH 093/137] [libc++] Fix Windows build error in
 include/filesystem

_LIBCPP_FUNC_VIS is redundant since the class is already annotated with
_LIBCPP_EXCEPTION_ABI.

Fixes this build error:

    In file included from fstream:188:
    filesystem(1350,3):  error: attribute 'dllimport' cannot be applied to member of 'dllimport' class
      _LIBCPP_FUNC_VIS
    __config(674,37):  note: expanded from macro '_LIBCPP_FUNC_VIS'
    #define _LIBCPP_FUNC_VIS            _LIBCPP_DLL_VIS
    __config(666,38):  note: expanded from macro '_LIBCPP_DLL_VIS'
    #  define _LIBCPP_DLL_VIS __declspec(dllimport)
    filesystem(1313,7):  note: previous attribute is here
    class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
    __config(675,37):  note: expanded from macro '_LIBCPP_EXCEPTION_ABI'
    #define _LIBCPP_EXCEPTION_ABI       _LIBCPP_DLL_VIS
    __config(666,38):  note: expanded from macro '_LIBCPP_DLL_VIS'
    #  define _LIBCPP_DLL_VIS __declspec(dllimport)

Differential Revision: https://reviews.llvm.org/D57354


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352525 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/filesystem | 1 -
 1 file changed, 1 deletion(-)

diff --git a/include/filesystem b/include/filesystem
index 6b33ffda7..7fb25116b 100644
--- a/include/filesystem
+++ b/include/filesystem
@@ -1347,7 +1347,6 @@ public:
     return __storage_->__what_.c_str();
   }
 
-  _LIBCPP_FUNC_VIS
   void __create_what(int __num_paths);
 
 private:
-- 
GitLab


From b7568024ed32688f5e1ce885716151f1f03a3791 Mon Sep 17 00:00:00 2001
From: Thomas Anderson <thomasanderson@google.com>
Date: Tue, 29 Jan 2019 23:19:45 +0000
Subject: [PATCH 094/137] [libc++] Fix Windows build error in <functional>

On my Windows system, __allocator is defined to nothing.  This change fixes build errors of the below form:

    In file included from algorithm:644:
    functional(1492,31):  error: expected member name or ';' after declaration specifiers
        const _Alloc& __allocator() const { return __f_.second(); }

Differential Revision: https://reviews.llvm.org/D57355


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352561 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/functional            | 11 ++++++-----
 test/support/nasty_macros.hpp |  1 +
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/include/functional b/include/functional
index 086610e61..def8a75f6 100644
--- a/include/functional
+++ b/include/functional
@@ -1488,8 +1488,9 @@ class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
     _LIBCPP_INLINE_VISIBILITY
     const _Target& __target() const { return __f_.first(); }
 
+    // WIN32 APIs may define __allocator, so use __get_allocator instead.
     _LIBCPP_INLINE_VISIBILITY
-    const _Alloc& __allocator() const { return __f_.second(); }
+    const _Alloc& __get_allocator() const { return __f_.second(); }
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __alloc_func(_Target&& __f)
@@ -1611,7 +1612,7 @@ __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
     typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
-    _Ap __a(__f_.__allocator());
+    _Ap __a(__f_.__get_allocator());
     typedef __allocator_destructor<_Ap> _Dp;
     unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
     ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a));
@@ -1622,7 +1623,7 @@ template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
 {
-    ::new (__p) __func(__f_.__target(), __f_.__allocator());
+    ::new (__p) __func(__f_.__target(), __f_.__get_allocator());
 }
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
@@ -1638,7 +1639,7 @@ __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
     typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
-    _Ap __a(__f_.__allocator());
+    _Ap __a(__f_.__get_allocator());
     __f_.destroy();
     __a.deallocate(this, 1);
 }
@@ -1924,7 +1925,7 @@ struct __policy
         typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type
             _FunAlloc;
         _Fun* __f = static_cast<_Fun*>(__s);
-        _FunAlloc __a(__f->__allocator());
+        _FunAlloc __a(__f->__get_allocator());
         __f->destroy();
         __a.deallocate(__f, 1);
     }
diff --git a/test/support/nasty_macros.hpp b/test/support/nasty_macros.hpp
index 7bc3f1e6a..30d0ec003 100644
--- a/test/support/nasty_macros.hpp
+++ b/test/support/nasty_macros.hpp
@@ -54,6 +54,7 @@
 // Test that libc++ doesn't use names reserved by WIN32 API Macros.
 // NOTE: Obviously we can only define these on non-windows platforms.
 #ifndef _WIN32
+#define __allocator NASTY_MACRO
 #define __deallocate NASTY_MACRO
 #define __out NASTY_MACRO
 #endif
-- 
GitLab


From 61be5f101473efa6a81219b0fdd7243fd7a6743e Mon Sep 17 00:00:00 2001
From: Thomas Anderson <thomasanderson@google.com>
Date: Wed, 30 Jan 2019 19:07:30 +0000
Subject: [PATCH 095/137] [libc++] Don't define exception destructors when
 using vcruntime

Exception destructors are provided by vcruntime.  Fixes link errors like:

    lld-link: error: duplicate symbol: "public: virtual __cdecl std::invalid_argument::~invalid_argument(void)" (??1invalid_argument@std@@UEAA@XZ) in stdexcept.obj and in libcpmt.lib(xthrow.obj)
    lld-link: error: duplicate symbol: "public: virtual __cdecl std::length_error::~length_error(void)" (??1length_error@std@@UEAA@XZ) in stdexcept.obj and in libcpmt.lib(xthrow.obj)
    lld-link: error: duplicate symbol: "public: virtual __cdecl std::out_of_range::~out_of_range(void)" (??1out_of_range@std@@UEAA@XZ) in stdexcept.obj and in libcpmt.lib(xthrow.obj)
    lld-link: error: duplicate symbol: "public: virtual __cdecl std::overflow_error::~overflow_error(void)" (??1overflow_error@std@@UEAA@XZ) in stdexcept.obj and in libcpmt.lib(xthrow.obj)

Differential Revision: https://reviews.llvm.org/D57425


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352646 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/stdexcept.cpp | 23 ++++++++---------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/src/stdexcept.cpp b/src/stdexcept.cpp
index 6ae35feed..179c25017 100644
--- a/src/stdexcept.cpp
+++ b/src/stdexcept.cpp
@@ -43,20 +43,6 @@ logic_error::operator=(const logic_error& le) _NOEXCEPT
     return *this;
 }
 
-#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
-
-logic_error::~logic_error() _NOEXCEPT
-{
-}
-
-const char*
-logic_error::what() const _NOEXCEPT
-{
-    return __imp_.c_str();
-}
-
-#endif
-
 runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str())
 {
 }
@@ -79,8 +65,10 @@ runtime_error::operator=(const runtime_error& le) _NOEXCEPT
 
 #if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
 
-runtime_error::~runtime_error() _NOEXCEPT
+const char*
+logic_error::what() const _NOEXCEPT
 {
+    return __imp_.c_str();
 }
 
 const char*
@@ -89,15 +77,20 @@ runtime_error::what() const _NOEXCEPT
     return __imp_.c_str();
 }
 
+#if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
+
+logic_error::~logic_error() _NOEXCEPT {}
 domain_error::~domain_error() _NOEXCEPT {}
 invalid_argument::~invalid_argument() _NOEXCEPT {}
 length_error::~length_error() _NOEXCEPT {}
 out_of_range::~out_of_range() _NOEXCEPT {}
 
+runtime_error::~runtime_error() _NOEXCEPT {}
 range_error::~range_error() _NOEXCEPT {}
 overflow_error::~overflow_error() _NOEXCEPT {}
 underflow_error::~underflow_error() _NOEXCEPT {}
 
+#endif
 #endif
 
 }  // std
-- 
GitLab


From c79c9331806f18f27c34e2041c03658b78194b24 Mon Sep 17 00:00:00 2001
From: Thomas Anderson <thomasanderson@google.com>
Date: Wed, 30 Jan 2019 19:08:32 +0000
Subject: [PATCH 096/137] [libc++] Don't define operator new/delete when using
 vcruntime

Fixes build errors on Windows without libc++abi of the form:

    new(173,36):  error: redeclaration of 'operator delete' cannot add 'dllexport' attribute
    _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p) _NOEXCEPT;
    vcruntime_new.h(87,16):  note: previous declaration is here
    void __CRTDECL operator delete(
    new(205,70):  error: redefinition of 'operator new'
    _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
    vcruntime_new.h(184,28):  note: previous definition is here
        inline void* __CRTDECL operator new(size_t _Size, _Writable_bytes_(_Size) void* _Where) noexcept
    new(206,70):  error: redefinition of 'operator new[]'
    _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
    vcruntime_new.h(199,28):  note: previous definition is here
        inline void* __CRTDECL operator new[](size_t _Size,
    new(207,40):  error: redefinition of 'operator delete'
    inline _LIBCPP_INLINE_VISIBILITY void  operator delete  (void*, void*) _NOEXCEPT {}
    vcruntime_new.h(190,27):  note: previous definition is here
        inline void __CRTDECL operator delete(void*, void*) noexcept
    new(208,40):  error: redefinition of 'operator delete[]'
    inline _LIBCPP_INLINE_VISIBILITY void  operator delete[](void*, void*) _NOEXCEPT {}
    vcruntime_new.h(206,27):  note: previous definition is here
        inline void __CRTDECL operator delete[](void*, void*) noexcept

Differential Revision: https://reviews.llvm.org/D57362


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352647 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/__config | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/include/__config b/include/__config
index 1bd593046..3ca661516 100644
--- a/include/__config
+++ b/include/__config
@@ -985,17 +985,18 @@ template <unsigned> struct __static_assert_check {};
 #define _DECLARE_C99_LDBL_MATH 1
 #endif
 
+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
+#  define _LIBCPP_DEFER_NEW_TO_VCRUNTIME
+#endif
+
 // If we are getting operator new from the MSVC CRT, then allocation overloads
 // for align_val_t were added in 19.12, aka VS 2017 version 15.3.
 #if defined(_LIBCPP_MSVCRT) && defined(_MSC_VER) && _MSC_VER < 1912
 #  define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
-#elif defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
-#  define _LIBCPP_DEFER_NEW_TO_VCRUNTIME
-#  if !defined(__cpp_aligned_new)
-     // We're defering to Microsoft's STL to provide aligned new et al. We don't
-     // have it unless the language feature test macro is defined.
-#    define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
-#  endif
+#elif defined(_LIBCPP_DEFER_NEW_TO_VCRUNTIME) && !defined(__cpp_aligned_new)
+   // We're defering to Microsoft's STL to provide aligned new et al. We don't
+   // have it unless the language feature test macro is defined.
+#  define _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
 #endif
 
 #if defined(__APPLE__)
-- 
GitLab


From 2ae08ad852f35bfff251e4332a122a07013c8bed Mon Sep 17 00:00:00 2001
From: Thomas Anderson <thomasanderson@google.com>
Date: Wed, 30 Jan 2019 19:09:41 +0000
Subject: [PATCH 097/137] [libc++] Explicitly initialize std::nothrow

When building on Windows without libc++abi, this change fixes a build error of the form:

    src/new.cpp(38,17):  error: chosen constructor is explicit in copy-initialization
    const nothrow_t nothrow = {};
    include/vcruntime_new.h(53,22):  note: explicit constructor declared here
                explicit nothrow_t() = default;

Differential Revision: https://reviews.llvm.org/D57351


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352648 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/new.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/new.cpp b/src/new.cpp
index eb5ce75f1..4acb69391 100644
--- a/src/new.cpp
+++ b/src/new.cpp
@@ -34,7 +34,7 @@ namespace std
 {
 
 #ifndef __GLIBCXX__
-const nothrow_t nothrow = {};
+const nothrow_t nothrow{};
 #endif
 
 #ifndef LIBSTDCXX
-- 
GitLab


From 30f748dc47baa3aba0860de34fbc949883d3fa4b Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Wed, 30 Jan 2019 19:27:26 +0000
Subject: [PATCH 098/137] [CMake] Use correct visibility for linked libraries
 in CMake

When linking library dependencies, we shouldn't need to export linked
libraries to dependents. We should be explicit about this in
target_link_libraries, otherwise other targets that depend on these such
as sanitizers get repeated (and possibly even conflicting) dependencies.

Differential Revision: https://reviews.llvm.org/D57456

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352654 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/CMakeLists.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 24489e8fb..79ea8d92a 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -241,7 +241,7 @@ if (LIBCXX_ENABLE_SHARED)
   if(COMMAND llvm_setup_rpath)
     llvm_setup_rpath(cxx_shared)
   endif()
-  target_link_libraries(cxx_shared ${LIBCXX_LIBRARIES})
+  target_link_libraries(cxx_shared PRIVATE ${LIBCXX_LIBRARIES})
   set_target_properties(cxx_shared
     PROPERTIES
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
@@ -265,7 +265,7 @@ endif()
 # Build the static library.
 if (LIBCXX_ENABLE_STATIC)
   add_library(cxx_static STATIC ${cxx_static_sources})
-  target_link_libraries(cxx_static ${LIBCXX_LIBRARIES})
+  target_link_libraries(cxx_static PRIVATE ${LIBCXX_LIBRARIES})
   set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
   set_target_properties(cxx_static
     PROPERTIES
-- 
GitLab


From 7b459f3f4847f52836c4aefc7c40b194df6f8700 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Wed, 30 Jan 2019 19:51:18 +0000
Subject: [PATCH 099/137] Revert "[CMake] Use correct visibility for linked
 libraries in CMake"

This reverts commit r352654: this broke libcxx and sanitizer bots.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352658 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/CMakeLists.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 79ea8d92a..24489e8fb 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -241,7 +241,7 @@ if (LIBCXX_ENABLE_SHARED)
   if(COMMAND llvm_setup_rpath)
     llvm_setup_rpath(cxx_shared)
   endif()
-  target_link_libraries(cxx_shared PRIVATE ${LIBCXX_LIBRARIES})
+  target_link_libraries(cxx_shared ${LIBCXX_LIBRARIES})
   set_target_properties(cxx_shared
     PROPERTIES
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
@@ -265,7 +265,7 @@ endif()
 # Build the static library.
 if (LIBCXX_ENABLE_STATIC)
   add_library(cxx_static STATIC ${cxx_static_sources})
-  target_link_libraries(cxx_static PRIVATE ${LIBCXX_LIBRARIES})
+  target_link_libraries(cxx_static ${LIBCXX_LIBRARIES})
   set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
   set_target_properties(cxx_static
     PROPERTIES
-- 
GitLab


From d4a208136709ffb4ab5db8b5938e0768d86c9d45 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Wed, 30 Jan 2019 23:18:05 +0000
Subject: [PATCH 100/137] [CMake] Use correct visibility for linked libraries
 in CMake

When linking library dependencies, we shouldn't need to export linked
libraries to dependents. We should be explicit about this in
target_link_libraries, otherwise other targets that depend on these such
as sanitizers get repeated (and possibly even conflicting) dependencies.

Differential Revision: https://reviews.llvm.org/D57456

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352688 91177308-0d34-0410-b5e6-96231b3b80d8
---
 benchmarks/CMakeLists.txt | 1 +
 lib/CMakeLists.txt        | 9 +++++++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
index 3823b87b3..637035e5c 100644
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -137,6 +137,7 @@ function(add_benchmark_test name source_file)
   add_executable(${libcxx_target} EXCLUDE_FROM_ALL ${source_file})
   add_dependencies(${libcxx_target} cxx cxx-headers google-benchmark-libcxx)
   add_dependencies(cxx-benchmarks ${libcxx_target})
+  target_link_libraries(${libcxx_target} ${LIBCXX_LIBRARIES})
   if (LIBCXX_ENABLE_SHARED)
     target_link_libraries(${libcxx_target} cxx_shared)
   else()
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 24489e8fb..7c5096da0 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -241,7 +241,7 @@ if (LIBCXX_ENABLE_SHARED)
   if(COMMAND llvm_setup_rpath)
     llvm_setup_rpath(cxx_shared)
   endif()
-  target_link_libraries(cxx_shared ${LIBCXX_LIBRARIES})
+  target_link_libraries(cxx_shared PRIVATE ${LIBCXX_LIBRARIES})
   set_target_properties(cxx_shared
     PROPERTIES
       LINK_FLAGS    "${LIBCXX_LINK_FLAGS}"
@@ -265,7 +265,7 @@ endif()
 # Build the static library.
 if (LIBCXX_ENABLE_STATIC)
   add_library(cxx_static STATIC ${cxx_static_sources})
-  target_link_libraries(cxx_static ${LIBCXX_LIBRARIES})
+  target_link_libraries(cxx_static PRIVATE ${LIBCXX_LIBRARIES})
   set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
   set_target_properties(cxx_static
     PROPERTIES
@@ -461,3 +461,8 @@ if (NOT CMAKE_CONFIGURATION_TYPES AND (LIBCXX_INSTALL_LIBRARY OR
                       -P "${LIBCXX_BINARY_DIR}/cmake_install.cmake")
     add_custom_target(install-libcxx DEPENDS install-cxx)
 endif()
+
+# TODO: This is needed by cxx-benchmarks but this variable isn't
+# available outside of the scope of this file so we need to export
+# it. This is not necessarily the cleanest solution.
+set(LIBCXX_LIBRARIES ${LIBCXX_LIBRARIES} PARENT_SCOPE)
-- 
GitLab


From 125313b00b6dc344b028542b4a6fa306ac1ff138 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Thu, 31 Jan 2019 18:54:26 +0000
Subject: [PATCH 101/137] Fix a bit of libc++-specific behavior in the regex
 tests; add a missing test. Reviewed as https://reviews.llvm.org/D57391 Thanks
 to Andrey Maksimov for the patch

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352781 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../re.alg/re.alg.match/exponential.pass.cpp  |  6 ++-
 .../re.alg.replace/exponential.pass.cpp       | 38 +++++++++++++++++++
 .../re.alg/re.alg.search/exponential.pass.cpp |  6 ++-
 3 files changed, 46 insertions(+), 4 deletions(-)
 create mode 100644 test/std/re/re.alg/re.alg.replace/exponential.pass.cpp

diff --git a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
index cadbc2cc2..f23bef36e 100644
--- a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
@@ -21,18 +21,20 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main() {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
     try {
-      std::regex_match(
+      bool b = std::regex_match(
           "aaaaaaaaaaaaaaaaaaaa",
           std::regex(
               "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
               op));
-      assert(false);
+      LIBCPP_ASSERT(false);
+      assert(b);
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
diff --git a/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp b/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
new file mode 100644
index 000000000..715aa0aff
--- /dev/null
+++ b/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+// UNSUPPORTED: libcpp-no-exceptions
+
+// template <class OutputIterator, class BidirectionalIterator,
+//           class traits, class charT, class ST, class SA>
+//     OutputIterator
+//     regex_replace(OutputIterator out,
+//                   BidirectionalIterator first, BidirectionalIterator last,
+//                   const basic_regex<charT, traits>& e,
+//                   const basic_string<charT, ST, SA>& fmt,
+//                   regex_constants::match_flag_type flags =
+//                                              regex_constants::match_default);
+
+#include <regex>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    try {
+        std::regex re("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa");
+        const char s[] = "aaaaaaaaaaaaaaaaaaaa";
+        std::string r = std::regex_replace(s, re, "123-&", std::regex_constants::format_sed);
+        LIBCPP_ASSERT(false);
+        assert(r == "123-aaaaaaaaaaaaaaaaaaaa");
+    } catch (const std::regex_error &e) {
+      assert(e.code() == std::regex_constants::error_complexity);
+    }
+}
diff --git a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
index 381aec155..6de3bbffd 100644
--- a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
@@ -21,18 +21,20 @@
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main() {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
     try {
-      std::regex_search(
+      bool b = std::regex_search(
           "aaaaaaaaaaaaaaaaaaaa",
           std::regex(
               "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
               op));
-      assert(false);
+      LIBCPP_ASSERT(false);
+      assert(b);
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
-- 
GitLab


From a5fae5335e312a9bfea81a58f8ac9f9cadcb09c3 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Fri, 1 Feb 2019 20:00:13 +0000
Subject: [PATCH 102/137] [libc++] Disentangle the 3 implementations of
 type_info

Summary:
We currently have effectively 3 implementations of type_info: one for
the Microsoft ABI, one that does not assume that there's a unique copy
of each RTTI in a progran, and one that assumes a unique copy.

Those 3 implementations are entangled into the same class with nested
ifdefs, which makes it very difficult to understand. Furthermore, the
benefit of doing this is rather small since the code that is duplicated
across implementations is just a couple of trivial lines.

This patch stamps out the 3 versions of type_info explicitly to increase
readability. It also explains what's going on with short comments, because
it's far from obvious.

Reviewers: EricWF, mclow.lists

Subscribers: christof, jkorous, dexonsmith

Differential Revision: https://reviews.llvm.org/D57606

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352905 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/typeinfo | 106 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 75 insertions(+), 31 deletions(-)

diff --git a/include/typeinfo b/include/typeinfo
index 451d9c950..5bcb6b2c1 100644
--- a/include/typeinfo
+++ b/include/typeinfo
@@ -79,48 +79,24 @@ public:
 namespace std  // purposefully not using versioning namespace
 {
 
+#if defined(_LIBCPP_ABI_MICROSOFT)
+
 class _LIBCPP_EXCEPTION_ABI type_info
 {
     type_info& operator=(const type_info&);
     type_info(const type_info&);
 
-#if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
-    _LIBCPP_INLINE_VISIBILITY
-    int __compare_nonunique_names(const type_info &__arg) const _NOEXCEPT
-    { return __builtin_strcmp(name(), __arg.name()); }
-#endif
-
-#if defined(_LIBCPP_ABI_MICROSOFT)
     mutable struct {
       const char *__undecorated_name;
       const char __decorated_name[1];
     } __data;
 
     int __compare(const type_info &__rhs) const _NOEXCEPT;
-#endif // _LIBCPP_ABI_MICROSOFT
-
-protected:
-#if !defined(_LIBCPP_ABI_MICROSOFT)
-#if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
-    // A const char* with the non-unique RTTI bit possibly set.
-    uintptr_t __type_name;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit type_info(const char* __n)
-      : __type_name(reinterpret_cast<uintptr_t>(__n)) {}
-#else
-    const char *__type_name;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit type_info(const char* __n) : __type_name(__n) {}
-#endif
-#endif // ! _LIBCPP_ABI_MICROSOFT
 
 public:
     _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
     virtual ~type_info();
 
-#if defined(_LIBCPP_ABI_MICROSOFT)
     const char *name() const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
@@ -134,8 +110,48 @@ public:
     bool operator==(const type_info& __arg) const _NOEXCEPT {
       return __compare(__arg) == 0;
     }
-#else
-#if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator!=(const type_info& __arg) const _NOEXCEPT
+    { return !operator==(__arg); }
+};
+
+#elif defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
+
+// This implementation of type_info does not assume always a unique copy of
+// the RTTI for a given type inside a program. It packs the pointer to the
+// type name into a uintptr_t and reserves the high bit of that pointer (which
+// is assumed to be free for use under the ABI in use) to represent whether
+// that specific copy of the RTTI can be assumed unique inside the program.
+// To implement equality-comparison of type_infos, we check whether BOTH
+// type_infos are guaranteed unique, and if so, we simply compare the addresses
+// of their type names instead of doing a deep string comparison, which is
+// faster. If at least one of the type_infos can't guarantee uniqueness, we
+// have no choice but to fall back to a deep string comparison.
+//
+// Note that the compiler is the one setting (or unsetting) the high bit of
+// the pointer when it constructs the type_info, depending on whether it can
+// guarantee uniqueness for that specific type_info.
+class _LIBCPP_EXCEPTION_ABI type_info
+{
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+
+    _LIBCPP_INLINE_VISIBILITY
+    int __compare_nonunique_names(const type_info &__arg) const _NOEXCEPT
+    { return __builtin_strcmp(name(), __arg.name()); }
+
+protected:
+    uintptr_t __type_name;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit type_info(const char* __n)
+      : __type_name(reinterpret_cast<uintptr_t>(__n)) {}
+
+public:
+    _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
+    virtual ~type_info();
+
     _LIBCPP_INLINE_VISIBILITY
     const char* name() const _NOEXCEPT
     {
@@ -174,7 +190,35 @@ public:
         return false;
       return __compare_nonunique_names(__arg) == 0;
     }
-#else
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator!=(const type_info& __arg) const _NOEXCEPT
+    { return !operator==(__arg); }
+};
+
+#else // !_LIBCPP_ABI_MICROSOFT && !_LIBCPP_HAS_NONUNIQUE_TYPEINFO
+
+// This implementation of type_info assumes a unique copy of the RTTI for a
+// given type inside a program. This is a valid assumption when abiding to
+// Itanium ABI (http://itanium-cxx-abi.github.io/cxx-abi/abi.html#vtable-components).
+// Under this assumption, we can always compare the addresses of the type names
+// to implement equality-comparison of type_infos instead of having to perform
+// a deep string comparison.
+class _LIBCPP_EXCEPTION_ABI type_info
+{
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+
+protected:
+    const char *__type_name;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit type_info(const char* __n) : __type_name(__n) {}
+
+public:
+    _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
+    virtual ~type_info();
+
     _LIBCPP_INLINE_VISIBILITY
     const char* name() const _NOEXCEPT
     { return __type_name; }
@@ -190,14 +234,14 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(const type_info& __arg) const _NOEXCEPT
     { return __type_name == __arg.__type_name; }
-#endif
-#endif // _LIBCPP_ABI_MICROSOFT
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const type_info& __arg) const _NOEXCEPT
     { return !operator==(__arg); }
 };
 
+#endif
+
 class _LIBCPP_EXCEPTION_ABI bad_cast
     : public exception
 {
-- 
GitLab


From 5d83dada720360f613bac9f3073580191c35a379 Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Fri, 1 Feb 2019 21:59:27 +0000
Subject: [PATCH 103/137] add a test and a couple minor bug fixes for the
 implicit-signed-integer-truncation sanitizer. This is PR#40566

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352926 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/locale                                               | 2 +-
 include/sstream                                              | 2 +-
 .../string.streams/stringstream.members/str.pass.cpp         | 5 +++++
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/include/locale b/include/locale
index f16d4ba1f..c3c05eb39 100644
--- a/include/locale
+++ b/include/locale
@@ -546,7 +546,7 @@ __num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __ex
         __exp = 'P';
     else if ((__x & 0x5F) == __exp)
     {
-        __exp |= 0x80;
+        __exp |= (char) 0x80;
         if (__in_units)
         {
             __in_units = false;
diff --git a/include/sstream b/include/sstream
index 71204e0fa..14c91971c 100644
--- a/include/sstream
+++ b/include/sstream
@@ -558,7 +558,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
             char_type* __p = const_cast<char_type*>(__str_.data());
             this->setg(__p, __p + __ninp, __hm_);
         }
-        return this->sputc(__c);
+        return this->sputc(traits_type::to_char_type(__c));
     }
     return traits_type::not_eof(__c);
 }
diff --git a/test/std/input.output/string.streams/stringstream.members/str.pass.cpp b/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
index b8fa28ddb..392a1680e 100644
--- a/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
@@ -58,4 +58,9 @@ int main()
         ss << i << ' ' << 321;
         assert(ss.str() == L"89 3219 ");
     }
+    {
+        std::stringstream ss;
+        ss.write("\xd1", 1);
+        assert(ss.str().length() == 1);
+    }
 }
-- 
GitLab


From 6146dbd36708c6724669f4d918d7d1e3f88eb3c3 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Fri, 1 Feb 2019 23:52:17 +0000
Subject: [PATCH 104/137] Handle cases where the dirent::d_type macros aren't
 defined

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352942 91177308-0d34-0410-b5e6-96231b3b80d8
---
 src/filesystem/directory_iterator.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/filesystem/directory_iterator.cpp b/src/filesystem/directory_iterator.cpp
index edecf69ef..ca88dee06 100644
--- a/src/filesystem/directory_iterator.cpp
+++ b/src/filesystem/directory_iterator.cpp
@@ -24,6 +24,8 @@ namespace detail {
 namespace {
 
 #if !defined(_LIBCPP_WIN32API)
+
+#if defined(DT_BLK)
 template <class DirEntT, class = decltype(DirEntT::d_type)>
 static file_type get_file_type(DirEntT* ent, int) {
   switch (ent->d_type) {
@@ -49,6 +51,7 @@ static file_type get_file_type(DirEntT* ent, int) {
   }
   return file_type::none;
 }
+#endif // defined(DT_BLK)
 
 template <class DirEntT>
 static file_type get_file_type(DirEntT* ent, long) {
-- 
GitLab


From 23b5c8797f8654a82662ca17e726c3df3ee7aa84 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sat, 2 Feb 2019 23:13:49 +0000
Subject: [PATCH 105/137] Move the feature test macros script to the utils
 directory.

It doesn't make a lot of sense to keep it with the tests,
deep into the test suite directonies.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@352970 91177308-0d34-0410-b5e6-96231b3b80d8
---
 docs/DesignDocs/FeatureTestMacros.rst         |  9 +++++----
 .../generate_feature_test_macro_components.py | 19 ++++++++++---------
 2 files changed, 15 insertions(+), 13 deletions(-)
 rename {test/std/language.support/support.limits/support.limits.general => utils}/generate_feature_test_macro_components.py (97%)

diff --git a/docs/DesignDocs/FeatureTestMacros.rst b/docs/DesignDocs/FeatureTestMacros.rst
index d55af96c6..2fbba6547 100644
--- a/docs/DesignDocs/FeatureTestMacros.rst
+++ b/docs/DesignDocs/FeatureTestMacros.rst
@@ -9,7 +9,9 @@ Overview
 ========
 
 Libc++ implements the C++ feature test macros as specified in the C++2a standard,
-and before that in non-normative guiding documents (`See cppreference <https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros>`)
+and before that in non-normative guiding documents
+(`See cppreference <https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros>`_)
+
 
 Design
 ======
@@ -23,8 +25,7 @@ lives in, and whether or not is is implemented by libc++. From this SSoA we
 have enough information to automatically generate the `<version>` header,
 the tests, and the documentation.
 
-Therefore we maintain a SSoA in
-`libcxx/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py`
+Therefore we maintain a SSoA in `libcxx/utils/generate_feature_test_macro_components.py`
 which doubles as a script to generate the following components:
 
 * The `<version>` header.
@@ -41,4 +42,4 @@ Whenever a feature test macro is added or changed, the table should be updated
 and the script should be re-ran. The script will clobber the existing test files
 and the documentation and it will generate a new `<version>` header as a
 temporary file. The generated `<version>` header should be merged with the
-existing one.
\ No newline at end of file
+existing one.
diff --git a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py b/utils/generate_feature_test_macro_components.py
similarity index 97%
rename from test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
rename to utils/generate_feature_test_macro_components.py
index 00b63d5eb..2bd80a858 100755
--- a/test/std/language.support/support.limits/support.limits.general/generate_feature_test_macro_components.py
+++ b/utils/generate_feature_test_macro_components.py
@@ -4,21 +4,22 @@ import os
 import tempfile
 
 def get_libcxx_paths():
-  script_path = os.path.dirname(os.path.abspath(__file__))
+  utils_path = os.path.dirname(os.path.abspath(__file__))
   script_name = os.path.basename(__file__)
-  assert os.path.exists(script_path)
-  depth = 5
-  src_root = script_path
-  for _ in xrange(0, 5):
-    src_root = os.path.dirname(src_root)
+  assert os.path.exists(utils_path)
+  src_root = os.path.dirname(utils_path)
   include_path = os.path.join(src_root, 'include')
   assert os.path.exists(include_path)
   docs_path = os.path.join(src_root, 'docs')
   assert os.path.exists(docs_path)
-  return script_path, script_name, src_root, include_path, docs_path
+  macro_test_path = os.path.join(src_root, 'test', 'std', 'language.support',
+                            'support.limits', 'support.limits.general')
+  assert os.path.exists(macro_test_path)
+  assert os.path.exists(os.path.join(macro_test_path, 'version.version.pass.cpp'))
+  return script_name, src_root, include_path, docs_path, macro_test_path
 
 
-script_path, script_name, source_root, include_path, docs_path = get_libcxx_paths()
+script_name, source_root, include_path, docs_path, macro_test_path = get_libcxx_paths()
 
 def has_header(h):
   h_path = os.path.join(include_path, h)
@@ -874,7 +875,7 @@ int main() {{}}
            cxx17_tests=generate_std_test(test_list, 'c++17').strip(),
            cxx2a_tests=generate_std_test(test_list, 'c++2a').strip())
     test_name = "{header}.version.pass.cpp".format(header=h)
-    out_path = os.path.join(script_path, test_name)
+    out_path = os.path.join(macro_test_path, test_name)
     with open(out_path, 'w') as f:
       f.write(test_body)
 
-- 
GitLab


From 79e853fd24dc71be7381395fa103c777e9d3f577 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Mon, 4 Feb 2019 20:02:26 +0000
Subject: [PATCH 106/137] [CMake] Support CMake variables for setting target,
 sysroot and toolchain

CMake has a standard way of setting target triple, sysroot and external
toolchain through CMAKE_<LANG>_COMPILER_TARGET, CMAKE_SYSROOT and
CMAKE_<LANG>_COMPILER_EXTERNAL_TOOLCHAIN. These are turned into
corresponding --target=, --sysroot= and --gcc-toolchain= variables add
included appended to CMAKE_<LANG>_FLAGS.

libunwind, libc++abi, libc++ provides their own mechanism through
<PROJECT>_TARGET_TRIPLE, <PROJECT>_SYSROOT and <PROJECT>_GCC_TOOLCHAIN
variables. These are also passed to lit via lit.site.cfg, and lit config
uses these to set the corresponding compiler flags when building tessts.

This means that there are two different ways of setting target, sysroot
and toolchain, but only one is properly supported in lit. This change
extends CMake build for libunwind, libc++abi and libc++ to also support
the CMake variables in addition to project specific ones in lit.

Differential Revision: https://reviews.llvm.org/D57670

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353084 91177308-0d34-0410-b5e6-96231b3b80d8
---
 CMakeLists.txt       | 23 +++++++++++++++++++----
 test/lit.site.cfg.in |  2 +-
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9e27ba41e..c6b05b61f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -224,6 +224,7 @@ option(LIBCXXABI_ENABLE_STATIC_UNWINDER "Statically link the LLVM unwinder." OFF
 
 # Target options --------------------------------------------------------------
 option(LIBCXX_BUILD_32_BITS "Build 32 bit libc++." ${LLVM_BUILD_32_BITS})
+set(LIBCXX_TARGET_TRIPLE "" CACHE STRING "Use alternate target triple.")
 set(LIBCXX_SYSROOT "" CACHE STRING "Use alternate sysroot.")
 set(LIBCXX_GCC_TOOLCHAIN "" CACHE STRING "Use alternate GCC toolchain.")
 
@@ -460,10 +461,24 @@ include(HandleLibcxxFlags)
 # 'config-ix' use them during feature checks. It also adds them to both
 # 'LIBCXX_COMPILE_FLAGS' and 'LIBCXX_LINK_FLAGS'
 add_target_flags_if(LIBCXX_BUILD_32_BITS "-m32")
-add_target_flags_if(LIBCXX_TARGET_TRIPLE "--target=${LIBCXX_TARGET_TRIPLE}")
-add_target_flags_if(LIBCXX_SYSROOT "--sysroot=${LIBCXX_SYSROOT}")
-add_target_flags_if(LIBCXX_GCC_TOOLCHAIN "--gcc-toolchain=${LIBCXX_GCC_TOOLCHAIN}")
-if (LIBCXX_TARGET_TRIPLE)
+
+if(LIBCXX_TARGET_TRIPLE)
+  add_target_flags("--target=${LIBCXX_TARGET_TRIPLE}")
+elseif(CMAKE_CXX_COMPILER_TARGET)
+  set(LIBCXX_TARGET_TRIPLE "${CMAKE_CXX_COMPILER_TARGET}")
+endif()
+if(LIBCXX_SYSROOT)
+  add_target_flags("--sysroot=${LIBCXX_SYSROOT}")
+elseif(CMAKE_SYSROOT)
+  set(LIBCXX_SYSROOT "${CMAKE_SYSROOT}")
+endif()
+if(LIBCXX_GCC_TOOLCHAIN)
+  add_target_flags("--gcc-toolchain=${LIBCXX_GCC_TOOLCHAIN}")
+elseif(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN)
+  set(LIBCXX_GCC_TOOLCHAIN "${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+endif()
+
+if(LIBCXX_TARGET_TRIPLE)
   set(TARGET_TRIPLE "${LIBCXX_TARGET_TRIPLE}")
 endif()
 
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
index 53f797268..cb7b62c9a 100644
--- a/test/lit.site.cfg.in
+++ b/test/lit.site.cfg.in
@@ -17,7 +17,7 @@ config.abi_library_path         = "@LIBCXX_CXX_ABI_LIBRARY_PATH@"
 config.configuration_variant    = "@LIBCXX_LIT_VARIANT@"
 config.host_triple              = "@LLVM_HOST_TRIPLE@"
 config.target_triple            = "@TARGET_TRIPLE@"
-config.use_target               = len("@LIBCXX_TARGET_TRIPLE@") > 0
+config.use_target               = bool("@LIBCXX_TARGET_TRIPLE@")
 config.sysroot                  = "@LIBCXX_SYSROOT@"
 config.gcc_toolchain            = "@LIBCXX_GCC_TOOLCHAIN@"
 config.generate_coverage        = "@LIBCXX_GENERATE_COVERAGE@"
-- 
GitLab


From e15dd4e32e99e70fa8c89f979fa5354e9769c4e5 Mon Sep 17 00:00:00 2001
From: JF Bastien <jfbastien@apple.com>
Date: Mon, 4 Feb 2019 20:31:13 +0000
Subject: [PATCH 107/137] Support tests in freestanding

Summary:
Freestanding is *weird*. The standard allows it to differ in a bunch of odd
manners from regular C++, and the committee would like to improve that
situation. I'd like to make libc++ behave better with what freestanding should
be, so that it can be a tool we use in improving the standard. To do that we
need to try stuff out, both with "freestanding the language mode" and
"freestanding the library subset".

Let's start with the super basic: run the libc++ tests in freestanding, using
clang as the compiler, and see what works. The easiest hack to do this:

In utils/libcxx/test/config.py add:

  self.cxx.compile_flags += ['-ffreestanding']

Run the tests and they all fail.

Why? Because in freestanding `main` isn't special. This "not special" property
has two effects: main doesn't get mangled, and main isn't allowed to omit its
`return` statement. The first means main gets mangled and the linker can't
create a valid executable for us to test. The second means we spew out warnings
(ew) and the compiler doesn't insert the `return` we omitted, and main just
falls of the end and does whatever undefined behavior (if you're luck, ud2
leading to non-zero return code).

Let's start my work with the basics. This patch changes all libc++ tests to
declare `main` as `int main(int, char**` so it mangles consistently (enabling us
to declare another `extern "C"` main for freestanding which calls the mangled
one), and adds `return 0;` to all places where it was missing. This touches 6124
files, and I apologize.

The former was done with The Magic Of Sed.

The later was done with a (not quite correct but decent) clang tool:

  https://gist.github.com/jfbastien/793819ff360baa845483dde81170feed

This works for most tests, though I did have to adjust a few places when e.g.
the test runs with `-x c`, macros are used for main (such as for the filesystem
tests), etc.

Once this is in we can create a freestanding bot which will prevent further
regressions. After that, we can start the real work of supporting C++
freestanding fairly well in libc++.

<rdar://problem/47754795>

Reviewers: ldionne, mclow.lists, EricWF

Subscribers: christof, jkorous, dexonsmith, arphaman, miyuki, libcxx-commits

Differential Revision: https://reviews.llvm.org/D57624

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353086 91177308-0d34-0410-b5e6-96231b3b80d8
---
 cmake/Modules/CheckLibcxxAtomic.cmake                  |  2 +-
 docs/DesignDocs/DebugMode.rst                          |  2 +-
 docs/DesignDocs/FileTimeType.rst                       |  3 ++-
 .../alg.random.shuffle/random_shuffle.cxx1z.pass.cpp   |  4 +++-
 .../random_shuffle.depr_in_cxx14.fail.cpp              |  4 +++-
 test/libcxx/algorithms/debug_less.pass.cpp             |  4 +++-
 test/libcxx/algorithms/half_positive.pass.cpp          |  4 +++-
 test/libcxx/algorithms/version.pass.cpp                |  4 +++-
 test/libcxx/atomics/atomics.align/align.pass.sh.cpp    |  4 +++-
 test/libcxx/atomics/atomics.flag/init_bool.pass.cpp    |  4 +++-
 .../atomics/diagnose_invalid_memory_order.fail.cpp     |  4 +++-
 test/libcxx/atomics/libcpp-has-no-threads.fail.cpp     |  4 +++-
 test/libcxx/atomics/libcpp-has-no-threads.pass.cpp     |  4 +++-
 test/libcxx/atomics/version.pass.cpp                   |  4 +++-
 .../libcxx/containers/associative/map/version.pass.cpp |  4 +++-
 .../associative/non_const_comparator.fail.cpp          |  4 +++-
 .../libcxx/containers/associative/set/version.pass.cpp |  4 +++-
 .../associative/tree_balance_after_insert.pass.cpp     |  4 +++-
 .../associative/tree_key_value_traits.pass.cpp         |  4 +++-
 .../containers/associative/tree_left_rotate.pass.cpp   |  4 +++-
 .../libcxx/containers/associative/tree_remove.pass.cpp |  4 +++-
 .../containers/associative/tree_right_rotate.pass.cpp  |  4 +++-
 .../containers/associative/undef_min_max.pass.cpp      |  4 +++-
 .../container.adaptors/queue/version.pass.cpp          |  4 +++-
 .../container.adaptors/stack/version.pass.cpp          |  4 +++-
 test/libcxx/containers/gnu_cxx/hash_map.pass.cpp       |  4 +++-
 test/libcxx/containers/gnu_cxx/hash_set.pass.cpp       |  4 +++-
 .../sequences/array/array.zero/db_back.pass.cpp        |  4 +++-
 .../sequences/array/array.zero/db_front.pass.cpp       |  4 +++-
 .../sequences/array/array.zero/db_indexing.pass.cpp    |  4 +++-
 .../libcxx/containers/sequences/array/version.pass.cpp |  4 +++-
 .../containers/sequences/deque/incomplete.pass.cpp     |  4 +++-
 .../containers/sequences/deque/pop_back_empty.pass.cpp |  4 +++-
 .../libcxx/containers/sequences/deque/version.pass.cpp |  4 +++-
 .../containers/sequences/forwardlist/version.pass.cpp  |  4 +++-
 .../sequences/list/list.cons/db_copy.pass.cpp          |  4 +++-
 .../sequences/list/list.cons/db_move.pass.cpp          |  4 +++-
 .../sequences/list/list.modifiers/emplace_db1.pass.cpp |  4 +++-
 .../list/list.modifiers/erase_iter_db1.pass.cpp        |  4 +++-
 .../list/list.modifiers/erase_iter_db2.pass.cpp        |  4 +++-
 .../list/list.modifiers/erase_iter_iter_db1.pass.cpp   |  4 +++-
 .../list/list.modifiers/erase_iter_iter_db2.pass.cpp   |  4 +++-
 .../list/list.modifiers/erase_iter_iter_db3.pass.cpp   |  4 +++-
 .../list/list.modifiers/erase_iter_iter_db4.pass.cpp   |  4 +++-
 .../list.modifiers/insert_iter_iter_iter_db1.pass.cpp  |  4 +++-
 .../list.modifiers/insert_iter_rvalue_db1.pass.cpp     |  4 +++-
 .../list.modifiers/insert_iter_size_value_db1.pass.cpp |  4 +++-
 .../list/list.modifiers/insert_iter_value_db1.pass.cpp |  4 +++-
 .../list/list.modifiers/pop_back_db1.pass.cpp          |  4 +++-
 .../list/list.ops/db_splice_pos_list.pass.cpp          |  4 +++-
 .../list/list.ops/db_splice_pos_list_iter.pass.cpp     |  4 +++-
 .../list.ops/db_splice_pos_list_iter_iter.pass.cpp     |  4 +++-
 test/libcxx/containers/sequences/list/version.pass.cpp |  4 +++-
 test/libcxx/containers/sequences/vector/asan.pass.cpp  |  4 ++--
 .../containers/sequences/vector/asan_throw.pass.cpp    |  4 +++-
 .../sequences/vector/const_value_type.pass.cpp         |  4 +++-
 .../containers/sequences/vector/db_back.pass.cpp       |  6 ++++--
 .../containers/sequences/vector/db_cback.pass.cpp      |  6 ++++--
 .../containers/sequences/vector/db_cfront.pass.cpp     |  6 ++++--
 .../containers/sequences/vector/db_cindex.pass.cpp     |  6 ++++--
 .../containers/sequences/vector/db_front.pass.cpp      |  6 ++++--
 .../containers/sequences/vector/db_index.pass.cpp      |  6 ++++--
 .../sequences/vector/db_iterators_2.pass.cpp           |  6 ++++--
 .../sequences/vector/db_iterators_3.pass.cpp           |  6 ++++--
 .../sequences/vector/db_iterators_4.pass.cpp           |  6 ++++--
 .../sequences/vector/db_iterators_5.pass.cpp           |  6 ++++--
 .../sequences/vector/db_iterators_6.pass.cpp           |  6 ++++--
 .../sequences/vector/db_iterators_7.pass.cpp           |  6 ++++--
 .../sequences/vector/db_iterators_8.pass.cpp           |  6 ++++--
 .../sequences/vector/pop_back_empty.pass.cpp           |  4 +++-
 .../vector/vector.cons/construct_iter_iter.pass.cpp    |  4 +++-
 .../vector.cons/construct_iter_iter_alloc.pass.cpp     |  4 +++-
 .../containers/sequences/vector/version.pass.cpp       |  4 +++-
 test/libcxx/containers/unord/key_value_traits.pass.cpp |  4 +++-
 test/libcxx/containers/unord/next_pow2.pass.cpp        |  2 +-
 test/libcxx/containers/unord/next_prime.pass.cpp       |  4 +++-
 .../containers/unord/non_const_comparator.fail.cpp     |  4 +++-
 .../containers/unord/unord.map/db_iterators_7.pass.cpp |  6 ++++--
 .../containers/unord/unord.map/db_iterators_8.pass.cpp |  6 ++++--
 .../unord/unord.map/db_local_iterators_7.pass.cpp      |  6 ++++--
 .../unord/unord.map/db_local_iterators_8.pass.cpp      |  6 ++++--
 .../libcxx/containers/unord/unord.map/version.pass.cpp |  4 +++-
 .../unord.set/missing_hash_specialization.fail.cpp     |  4 +++-
 .../libcxx/containers/unord/unord.set/version.pass.cpp |  4 +++-
 .../containers/db_associative_container_tests.pass.cpp |  4 +++-
 .../db_sequence_container_iterators.pass.cpp           |  4 +++-
 test/libcxx/debug/containers/db_string.pass.cpp        |  4 +++-
 .../debug/containers/db_unord_container_tests.pass.cpp |  4 +++-
 test/libcxx/debug/debug_abort.pass.cpp                 |  2 +-
 test/libcxx/debug/debug_throw.pass.cpp                 |  4 +++-
 test/libcxx/debug/debug_throw_register.pass.cpp        |  4 +++-
 .../depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp     |  4 +++-
 .../auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp           |  4 +++-
 test/libcxx/depr/depr.c.headers/ciso646.pass.cpp       |  4 +++-
 test/libcxx/depr/depr.c.headers/complex.h.pass.cpp     |  4 +++-
 test/libcxx/depr/depr.c.headers/extern_c.pass.cpp      |  4 +++-
 test/libcxx/depr/depr.c.headers/locale_h.pass.cpp      |  4 +++-
 test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp      |  4 +++-
 .../adaptors.depr_in_cxx11.fail.cpp                    |  4 +++-
 .../depr.function.objects/depr.adaptors.cxx1z.pass.cpp |  4 +++-
 test/libcxx/depr/depr.str.strstreams/version.pass.cpp  |  4 +++-
 .../libcxx/depr/enable_removed_cpp17_features.pass.cpp |  4 +++-
 .../depr/exception.unexpected/get_unexpected.pass.cpp  |  4 +++-
 .../depr/exception.unexpected/set_unexpected.pass.cpp  |  4 +++-
 .../depr/exception.unexpected/unexpected.pass.cpp      |  4 +++-
 .../unexpected_disabled_cpp17.fail.cpp                 |  4 +++-
 .../diagnostics/assertions/version_cassert.pass.cpp    |  4 +++-
 test/libcxx/diagnostics/enable_nodiscard.fail.cpp      |  4 +++-
 .../enable_nodiscard_disable_after_cxx17.fail.cpp      |  4 +++-
 .../enable_nodiscard_disable_nodiscard_ext.fail.cpp    |  4 +++-
 test/libcxx/diagnostics/errno/version_cerrno.pass.cpp  |  4 +++-
 test/libcxx/diagnostics/nodiscard.pass.cpp             |  4 +++-
 test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp  |  4 +++-
 test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp  |  4 +++-
 test/libcxx/diagnostics/nodiscard_extensions.fail.cpp  |  4 +++-
 test/libcxx/diagnostics/nodiscard_extensions.pass.cpp  |  4 +++-
 .../libcxx/diagnostics/std.exceptions/version.pass.cpp |  4 +++-
 test/libcxx/diagnostics/syserr/version.pass.cpp        |  4 +++-
 test/libcxx/double_include.sh.cpp                      |  2 +-
 .../header.algorithm.synop/includes.pass.cpp           |  4 +++-
 test/libcxx/experimental/algorithms/version.pass.cpp   |  4 +++-
 .../diagnostics/syserr/use_header_warning.fail.cpp     |  4 +++-
 .../experimental/diagnostics/syserr/version.pass.cpp   |  4 +++-
 test/libcxx/experimental/filesystem/version.pass.cpp   |  4 +++-
 .../support.coroutines/dialect_support.sh.cpp          |  4 +++-
 .../language.support/support.coroutines/version.sh.cpp |  4 +++-
 .../construct_piecewise_pair.pass.cpp                  |  4 +++-
 .../db_deallocate.pass.cpp                             |  4 +++-
 .../memory.resource.adaptor.mem/db_deallocate.pass.cpp |  4 +++-
 .../header_deque_libcpp_version.pass.cpp               |  4 +++-
 .../header_forward_list_libcpp_version.pass.cpp        |  4 +++-
 .../header_list_libcpp_version.pass.cpp                |  4 +++-
 .../header_map_libcpp_version.pass.cpp                 |  4 +++-
 .../header_regex_libcpp_version.pass.cpp               |  4 +++-
 .../header_set_libcpp_version.pass.cpp                 |  4 +++-
 .../header_string_libcpp_version.pass.cpp              |  4 +++-
 .../header_unordered_map_libcpp_version.pass.cpp       |  4 +++-
 .../header_unordered_set_libcpp_version.pass.cpp       |  4 +++-
 .../header_vector_libcpp_version.pass.cpp              |  4 +++-
 .../global_memory_resource_lifetime.pass.cpp           |  4 +++-
 .../new_delete_resource_lifetime.pass.cpp              |  4 +++-
 .../memory/memory.resource.synop/version.pass.cpp      |  4 +++-
 .../numerics/numeric.ops/use_header_warning.fail.cpp   |  4 +++-
 .../experimental/numerics/numeric.ops/version.pass.cpp |  4 +++-
 .../strings/string.view/use_header_warning.fail.cpp    |  4 +++-
 .../experimental/strings/string.view/version.pass.cpp  |  4 +++-
 .../utilities/any/use_header_warning.fail.cpp          |  4 +++-
 .../libcxx/experimental/utilities/any/version.pass.cpp |  4 +++-
 .../experimental/utilities/meta/version.pass.cpp       |  4 +++-
 .../utilities/optional/use_header_warning.fail.cpp     |  4 +++-
 .../experimental/utilities/optional/version.pass.cpp   |  4 +++-
 .../utilities/ratio/use_header_warning.fail.cpp        |  4 +++-
 .../experimental/utilities/ratio/version.pass.cpp      |  4 +++-
 .../utilities/time/use_header_warning.fail.cpp         |  4 +++-
 .../experimental/utilities/time/version.pass.cpp       |  4 +++-
 .../utilities/tuple/use_header_warning.fail.cpp        |  4 +++-
 .../experimental/utilities/tuple/version.pass.cpp      |  4 +++-
 .../experimental/utilities/utility/version.pass.cpp    |  4 +++-
 test/libcxx/extensions/hash/specializations.fail.cpp   |  4 +++-
 test/libcxx/extensions/hash/specializations.pass.cpp   |  4 +++-
 .../libcxx/extensions/hash_map/const_iterator.fail.cpp |  4 +++-
 test/libcxx/extensions/nothing_to_do.pass.cpp          |  4 +++-
 test/libcxx/fuzzing/nth_element.cpp                    |  2 +-
 test/libcxx/fuzzing/partial_sort.cpp                   |  2 +-
 test/libcxx/fuzzing/partial_sort_copy.cpp              |  2 +-
 test/libcxx/fuzzing/partition.cpp                      |  2 +-
 test/libcxx/fuzzing/partition_copy.cpp                 |  2 +-
 test/libcxx/fuzzing/regex_ECMAScript.cpp               |  2 +-
 test/libcxx/fuzzing/regex_POSIX.cpp                    |  2 +-
 test/libcxx/fuzzing/regex_awk.cpp                      |  2 +-
 test/libcxx/fuzzing/regex_egrep.cpp                    |  2 +-
 test/libcxx/fuzzing/regex_extended.cpp                 |  2 +-
 test/libcxx/fuzzing/regex_grep.cpp                     |  2 +-
 test/libcxx/fuzzing/sort.cpp                           |  2 +-
 test/libcxx/fuzzing/stable_partition.cpp               |  2 +-
 test/libcxx/fuzzing/stable_sort.cpp                    |  2 +-
 test/libcxx/fuzzing/unique.cpp                         |  2 +-
 test/libcxx/fuzzing/unique_copy.cpp                    |  2 +-
 test/libcxx/include_as_c.sh.cpp                        |  6 +++++-
 .../no.global.filesystem.namespace/fopen.fail.cpp      |  4 +++-
 .../no.global.filesystem.namespace/rename.fail.cpp     |  4 +++-
 .../file.streams/c.files/version_ccstdio.pass.cpp      |  4 +++-
 .../file.streams/c.files/version_cinttypes.pass.cpp    |  4 +++-
 .../fstreams/filebuf/traits_mismatch.fail.cpp          |  4 +++-
 .../file.streams/fstreams/fstream.close.pass.cpp       |  4 +++-
 .../fstreams/fstream.cons/wchar_pointer.pass.cpp       |  4 +++-
 .../fstream.members/open_wchar_pointer.pass.cpp        |  4 +++-
 .../fstreams/ifstream.cons/wchar_pointer.pass.cpp      |  4 +++-
 .../ifstream.members/open_wchar_pointer.pass.cpp       |  4 +++-
 .../fstreams/ofstream.cons/wchar_pointer.pass.cpp      |  4 +++-
 .../ofstream.members/open_wchar_pointer.pass.cpp       |  4 +++-
 .../file.streams/fstreams/traits_mismatch.fail.cpp     |  4 +++-
 .../file.streams/fstreams/version.pass.cpp             |  4 +++-
 .../class.path/path.itr/iterator_db.pass.cpp           |  4 +++-
 .../reverse_iterator_produces_diagnostic.fail.cpp      |  4 +++-
 .../class.path/path.req/is_pathable.pass.cpp           |  4 +++-
 .../input.output/filesystems/convert_file_time.sh.cpp  |  4 +++-
 test/libcxx/input.output/filesystems/version.pass.cpp  |  4 +++-
 .../input.streams/traits_mismatch.fail.cpp             |  4 +++-
 .../iostream.format/input.streams/version.pass.cpp     |  4 +++-
 .../output.streams/traits_mismatch.fail.cpp            |  4 +++-
 .../iostream.format/output.streams/version.pass.cpp    |  4 +++-
 .../iostream.format/std.manip/version.pass.cpp         |  4 +++-
 .../input.output/iostream.forward/version.pass.cpp     |  4 +++-
 .../input.output/iostream.objects/version.pass.cpp     |  4 +++-
 .../input.output/iostreams.base/version.pass.cpp       |  4 +++-
 .../input.output/stream.buffers/version.pass.cpp       |  4 +++-
 .../string.streams/traits_mismatch.fail.cpp            |  4 +++-
 .../input.output/string.streams/version.pass.cpp       |  4 +++-
 test/libcxx/iterators/failed.pass.cpp                  |  4 +++-
 test/libcxx/iterators/trivial_iterators.pass.cpp       |  4 +++-
 test/libcxx/iterators/version.pass.cpp                 |  4 +++-
 test/libcxx/language.support/cmp/version.pass.cpp      |  4 +++-
 test/libcxx/language.support/cstdint/version.pass.cpp  |  4 +++-
 .../language.support/cxa_deleted_virtual.pass.cpp      |  4 +++-
 test/libcxx/language.support/has_c11_features.pass.cpp |  4 +++-
 .../support.dynamic/libcpp_deallocate.sh.cpp           |  4 +++-
 .../support.dynamic/new_faligned_allocation.sh.cpp     |  4 +++-
 .../language.support/support.dynamic/version.pass.cpp  |  4 +++-
 .../support.exception/version.pass.cpp                 |  4 +++-
 .../language.support/support.initlist/version.pass.cpp |  4 +++-
 .../support.limits/c.limits/version_cfloat.pass.cpp    |  4 +++-
 .../support.limits/c.limits/version_climits.pass.cpp   |  4 +++-
 .../support.limits/limits/version.pass.cpp             |  4 +++-
 .../language.support/support.limits/version.pass.cpp   |  4 +++-
 .../language.support/support.rtti/version.pass.cpp     |  4 +++-
 .../support.runtime/version_csetjmp.pass.cpp           |  4 +++-
 .../support.runtime/version_csignal.pass.cpp           |  4 +++-
 .../support.runtime/version_cstdarg.pass.cpp           |  4 +++-
 .../support.runtime/version_cstdbool.pass.cpp          |  4 +++-
 .../support.runtime/version_cstdlib.pass.cpp           |  4 +++-
 .../support.runtime/version_ctime.pass.cpp             |  4 +++-
 .../language.support/support.types/version.pass.cpp    |  4 +++-
 test/libcxx/libcpp_alignof.pass.cpp                    |  3 ++-
 test/libcxx/libcpp_version.pass.cpp                    |  4 +++-
 test/libcxx/localization/c.locales/version.pass.cpp    |  4 +++-
 .../locale.categories/__scan_keyword.pass.cpp          |  4 +++-
 .../libcxx/localization/locale.stdcvt/version.pass.cpp |  4 +++-
 .../conversions/conversions.string/ctor_move.pass.cpp  |  4 +++-
 .../locale/locale.types/locale.facet/facet.pass.cpp    |  4 +++-
 .../locales/locale/locale.types/locale.id/id.pass.cpp  |  4 +++-
 test/libcxx/localization/version.pass.cpp              |  4 +++-
 test/libcxx/memory/aligned_allocation_macro.pass.cpp   |  4 +++-
 test/libcxx/memory/is_allocator.pass.cpp               |  4 +++-
 test/libcxx/modules/cinttypes_exports.sh.cpp           |  4 +++-
 test/libcxx/modules/clocale_exports.sh.cpp             |  4 +++-
 test/libcxx/modules/cstdint_exports.sh.cpp             |  4 +++-
 test/libcxx/modules/inttypes_h_exports.sh.cpp          |  4 +++-
 test/libcxx/modules/stdint_h_exports.sh.cpp            |  4 +++-
 test/libcxx/numerics/c.math/constexpr-fns.pass.cpp     |  4 +++-
 test/libcxx/numerics/c.math/ctgmath.pass.cpp           |  4 +++-
 .../numerics/c.math/fdelayed-template-parsing.sh.cpp   |  4 +++-
 test/libcxx/numerics/c.math/tgmath_h.pass.cpp          |  4 +++-
 test/libcxx/numerics/c.math/version_cmath.pass.cpp     |  4 +++-
 test/libcxx/numerics/cfenv/version.pass.cpp            |  4 +++-
 test/libcxx/numerics/complex.number/__sqr.pass.cpp     |  4 +++-
 .../numerics/complex.number/ccmplx/ccomplex.pass.cpp   |  4 +++-
 test/libcxx/numerics/complex.number/version.pass.cpp   |  4 +++-
 test/libcxx/numerics/numarray/version.pass.cpp         |  4 +++-
 test/libcxx/numerics/numeric.ops/version.pass.cpp      |  4 +++-
 .../numerics/rand/rand.synopsis/version.pass.cpp       |  4 +++-
 test/libcxx/selftest/not_test.sh.cpp                   |  2 +-
 test/libcxx/selftest/test.arc.pass.mm                  |  4 +---
 test/libcxx/selftest/test.pass.cpp                     |  4 +++-
 test/libcxx/selftest/test.pass.mm                      |  4 +---
 test/libcxx/selftest/test.sh.cpp                       |  4 +++-
 test/libcxx/selftest/test_macros.pass.cpp              |  4 +++-
 .../string.modifiers/clear_and_shrink_db1.pass.cpp     |  6 ++++--
 .../string.modifiers/erase_iter_db1.pass.cpp           |  6 ++++--
 .../string.modifiers/erase_iter_db2.pass.cpp           |  6 ++++--
 .../string.modifiers/erase_iter_iter_db1.pass.cpp      |  6 ++++--
 .../string.modifiers/erase_iter_iter_db2.pass.cpp      |  6 ++++--
 .../string.modifiers/erase_iter_iter_db3.pass.cpp      |  6 ++++--
 .../string.modifiers/erase_iter_iter_db4.pass.cpp      |  6 ++++--
 .../string.modifiers/erase_pop_back_db1.pass.cpp       |  4 +++-
 .../string.modifiers/insert_iter_char_db1.pass.cpp     |  4 +++-
 .../insert_iter_size_char_db1.pass.cpp                 |  4 +++-
 .../resize_default_initialized.pass.cpp                |  4 +++-
 test/libcxx/strings/c.strings/version_cctype.pass.cpp  |  4 +++-
 test/libcxx/strings/c.strings/version_cstring.pass.cpp |  4 +++-
 test/libcxx/strings/c.strings/version_cuchar.pass.cpp  |  4 +++-
 test/libcxx/strings/c.strings/version_cwchar.pass.cpp  |  4 +++-
 test/libcxx/strings/c.strings/version_cwctype.pass.cpp |  4 +++-
 test/libcxx/strings/iterators.exceptions.pass.cpp      |  4 +++-
 test/libcxx/strings/iterators.noexcept.pass.cpp        |  4 +++-
 test/libcxx/strings/version.pass.cpp                   |  4 +++-
 .../futures/futures.promise/set_exception.pass.cpp     |  4 +++-
 .../set_exception_at_thread_exit.pass.cpp              |  4 +++-
 test/libcxx/thread/futures/futures.task/types.pass.cpp |  4 +++-
 test/libcxx/thread/futures/version.pass.cpp            |  4 +++-
 ...PR30202_notify_from_pthread_created_thread.pass.cpp |  4 +++-
 .../thread.condition.condvar/native_handle.pass.cpp    |  4 +++-
 test/libcxx/thread/thread.condition/version.pass.cpp   |  4 +++-
 .../thread.mutex.class/native_handle.pass.cpp          |  4 +++-
 .../thread.mutex.recursive/native_handle.pass.cpp      |  4 +++-
 .../thread_safety_annotations_not_enabled.pass.cpp     |  4 +++-
 .../thread.mutex/thread_safety_lock_guard.pass.cpp     |  4 +++-
 .../thread.mutex/thread_safety_lock_unlock.pass.cpp    |  4 +++-
 .../thread.mutex/thread_safety_missing_unlock.fail.cpp |  4 +++-
 .../thread_safety_requires_capability.pass.cpp         |  4 +++-
 test/libcxx/thread/thread.mutex/version.pass.cpp       |  4 +++-
 .../thread.thread.member/native_handle.pass.cpp        |  4 +++-
 .../thread.threads/thread.thread.class/types.pass.cpp  |  4 +++-
 .../thread.thread.this/sleep_for.pass.cpp              |  4 +++-
 test/libcxx/thread/thread.threads/version.pass.cpp     |  4 +++-
 test/libcxx/type_traits/convert_to_integral.pass.cpp   |  4 +++-
 test/libcxx/type_traits/lazy_metafunctions.pass.cpp    |  4 +++-
 test/libcxx/utilities/any/size_and_alignment.pass.cpp  |  4 +++-
 test/libcxx/utilities/any/small_type.pass.cpp          |  4 +++-
 test/libcxx/utilities/any/version.pass.cpp             |  4 +++-
 .../func.require/bullet_1_2_3.pass.cpp                 |  4 +++-
 .../func.require/bullet_4_5_6.pass.cpp                 |  4 +++-
 .../function.objects/func.require/bullet_7.pass.cpp    |  4 +++-
 .../function.objects/func.require/invoke.pass.cpp      |  4 +++-
 .../utilities/function.objects/refwrap/binary.pass.cpp |  4 +++-
 .../utilities/function.objects/refwrap/unary.pass.cpp  |  4 +++-
 ...r_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp |  4 +++-
 .../libcxx/utilities/function.objects/version.pass.cpp |  4 +++-
 .../get_pointer_safety_cxx03.pass.cpp                  |  4 +++-
 .../get_pointer_safety_new_abi.pass.cpp                |  4 +++-
 .../memory/util.smartptr/race_condition.pass.cpp       |  4 +++-
 .../function_type_default_deleter.fail.cpp             |  4 +++-
 test/libcxx/utilities/memory/version.pass.cpp          |  4 +++-
 test/libcxx/utilities/meta/is_referenceable.pass.cpp   |  4 +++-
 .../meta.unary.prop/__has_operator_addressof.pass.cpp  |  4 +++-
 .../missing_is_aggregate_trait.fail.cpp                |  4 +++-
 test/libcxx/utilities/meta/version.pass.cpp            |  4 +++-
 .../optional.object.assign/copy.pass.cpp               |  4 +++-
 .../optional.object.assign/move.pass.cpp               |  4 +++-
 .../optional.object/optional.object.ctor/copy.pass.cpp |  4 +++-
 .../optional.object/optional.object.ctor/move.pass.cpp |  4 +++-
 .../optional/optional.object/triviality.abi.pass.cpp   |  4 +++-
 test/libcxx/utilities/optional/version.pass.cpp        |  4 +++-
 test/libcxx/utilities/ratio/version.pass.cpp           |  4 +++-
 .../libcxx/utilities/template.bitset/includes.pass.cpp |  4 +++-
 test/libcxx/utilities/template.bitset/version.pass.cpp |  4 +++-
 .../time/date.time/asctime.thread-unsafe.fail.cpp      |  4 +++-
 .../time/date.time/ctime.thread-unsafe.fail.cpp        |  4 +++-
 .../time/date.time/gmtime.thread-unsafe.fail.cpp       |  4 +++-
 .../time/date.time/localtime.thread-unsafe.fail.cpp    |  4 +++-
 test/libcxx/utilities/time/version.pass.cpp            |  4 +++-
 .../utilities/tuple/tuple.tuple/empty_member.pass.cpp  |  4 +++-
 .../PR20855_tuple_ref_binding_diagnostics.fail.cpp     |  4 +++-
 ...ble_reduced_arity_initialization_extension.pass.cpp |  4 +++-
 ...ble_reduced_arity_initialization_extension.pass.cpp |  4 +++-
 test/libcxx/utilities/tuple/version.pass.cpp           |  4 +++-
 test/libcxx/utilities/type.index/version.pass.cpp      |  4 +++-
 .../utilities/utility/__is_inplace_index.pass.cpp      |  4 +++-
 .../utilities/utility/__is_inplace_type.pass.cpp       |  4 +++-
 .../utilities/utility/pairs/pairs.pair/U_V.pass.cpp    |  4 +++-
 .../pairs/pairs.pair/assign_tuple_like.pass.cpp        |  4 +++-
 .../pairs/pairs.pair/const_first_const_second.pass.cpp |  4 +++-
 .../utility/pairs/pairs.pair/const_pair_U_V.pass.cpp   |  4 +++-
 .../utility/pairs/pairs.pair/default.pass.cpp          |  4 +++-
 .../pairs.pair/non_trivial_copy_move_ABI.pass.cpp      |  3 ++-
 .../pairs/pairs.pair/pair.tuple_element.fail.cpp       |  4 +++-
 .../utility/pairs/pairs.pair/piecewise.pass.cpp        |  4 +++-
 .../utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp      |  4 +++-
 .../pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp    |  3 ++-
 test/libcxx/utilities/utility/version.pass.cpp         |  4 +++-
 .../variant.helper/variant_alternative.fail.cpp        |  4 +++-
 .../variant/variant.variant/variant_size.pass.cpp      |  4 +++-
 test/libcxx/utilities/variant/version.pass.cpp         |  4 +++-
 test/nothing_to_do.pass.cpp                            |  4 +++-
 .../algorithms/alg.c.library/tested_elsewhere.pass.cpp |  4 +++-
 .../alg.modifying.operations/alg.copy/copy.pass.cpp    |  4 +++-
 .../alg.copy/copy_backward.pass.cpp                    |  4 +++-
 .../alg.modifying.operations/alg.copy/copy_if.pass.cpp |  4 +++-
 .../alg.modifying.operations/alg.copy/copy_n.pass.cpp  |  4 +++-
 .../alg.modifying.operations/alg.fill/fill.pass.cpp    |  4 +++-
 .../alg.modifying.operations/alg.fill/fill_n.pass.cpp  |  4 +++-
 .../alg.generate/generate.pass.cpp                     |  4 +++-
 .../alg.generate/generate_n.pass.cpp                   |  4 +++-
 .../alg.modifying.operations/alg.move/move.pass.cpp    |  4 +++-
 .../alg.move/move_backward.pass.cpp                    |  4 +++-
 .../alg.partitions/is_partitioned.pass.cpp             |  4 +++-
 .../alg.partitions/partition.pass.cpp                  |  4 +++-
 .../alg.partitions/partition_copy.pass.cpp             |  4 +++-
 .../alg.partitions/partition_point.pass.cpp            |  4 +++-
 .../alg.partitions/stable_partition.pass.cpp           |  4 +++-
 .../alg.random.sample/sample.fail.cpp                  |  4 +++-
 .../alg.random.sample/sample.pass.cpp                  |  4 +++-
 .../alg.random.sample/sample.stable.pass.cpp           |  4 +++-
 .../alg.random.shuffle/random_shuffle.pass.cpp         |  3 ++-
 .../alg.random.shuffle/random_shuffle_rand.pass.cpp    |  5 +++--
 .../alg.random.shuffle/random_shuffle_urng.pass.cpp    |  4 +++-
 .../alg.remove/remove.pass.cpp                         |  4 +++-
 .../alg.remove/remove_copy.pass.cpp                    |  4 +++-
 .../alg.remove/remove_copy_if.pass.cpp                 |  4 +++-
 .../alg.remove/remove_if.pass.cpp                      |  4 +++-
 .../alg.replace/replace.pass.cpp                       |  4 +++-
 .../alg.replace/replace_copy.pass.cpp                  |  4 +++-
 .../alg.replace/replace_copy_if.pass.cpp               |  4 +++-
 .../alg.replace/replace_if.pass.cpp                    |  4 +++-
 .../alg.reverse/reverse.pass.cpp                       |  4 +++-
 .../alg.reverse/reverse_copy.pass.cpp                  |  4 +++-
 .../alg.rotate/rotate.pass.cpp                         |  4 +++-
 .../alg.rotate/rotate_copy.pass.cpp                    |  4 +++-
 .../alg.swap/iter_swap.pass.cpp                        |  4 +++-
 .../alg.swap/swap_ranges.pass.cpp                      |  4 +++-
 .../alg.transform/binary_transform.pass.cpp            |  4 +++-
 .../alg.transform/unary_transform.pass.cpp             |  4 +++-
 .../alg.unique/unique.pass.cpp                         |  4 +++-
 .../alg.unique/unique_copy.pass.cpp                    |  4 +++-
 .../alg.unique/unique_copy_pred.pass.cpp               |  4 +++-
 .../alg.unique/unique_pred.pass.cpp                    |  4 +++-
 .../alg.modifying.operations/nothing_to_do.pass.cpp    |  4 +++-
 .../alg.adjacent.find/adjacent_find.pass.cpp           |  4 +++-
 .../alg.adjacent.find/adjacent_find_pred.pass.cpp      |  4 +++-
 .../alg.nonmodifying/alg.all_of/all_of.pass.cpp        |  4 +++-
 .../alg.nonmodifying/alg.any_of/any_of.pass.cpp        |  4 +++-
 .../alg.nonmodifying/alg.count/count.pass.cpp          |  4 +++-
 .../alg.nonmodifying/alg.count/count_if.pass.cpp       |  4 +++-
 .../alg.nonmodifying/alg.equal/equal.pass.cpp          |  4 +++-
 .../alg.nonmodifying/alg.equal/equal_pred.pass.cpp     |  4 +++-
 .../alg.nonmodifying/alg.find.end/find_end.pass.cpp    |  4 +++-
 .../alg.find.end/find_end_pred.pass.cpp                |  4 +++-
 .../alg.find.first.of/find_first_of.pass.cpp           |  4 +++-
 .../alg.find.first.of/find_first_of_pred.pass.cpp      |  4 +++-
 .../algorithms/alg.nonmodifying/alg.find/find.pass.cpp |  4 +++-
 .../alg.nonmodifying/alg.find/find_if.pass.cpp         |  4 +++-
 .../alg.nonmodifying/alg.find/find_if_not.pass.cpp     |  4 +++-
 .../alg.nonmodifying/alg.foreach/for_each_n.pass.cpp   |  4 +++-
 .../alg.nonmodifying/alg.foreach/test.pass.cpp         |  4 +++-
 .../alg.is_permutation/is_permutation.pass.cpp         |  4 +++-
 .../alg.is_permutation/is_permutation_pred.pass.cpp    |  4 +++-
 .../alg.nonmodifying/alg.none_of/none_of.pass.cpp      |  4 +++-
 .../alg.nonmodifying/alg.search/search.pass.cpp        |  4 +++-
 .../alg.nonmodifying/alg.search/search_n.pass.cpp      |  4 +++-
 .../alg.nonmodifying/alg.search/search_n_pred.pass.cpp |  4 +++-
 .../alg.nonmodifying/alg.search/search_pred.pass.cpp   |  4 +++-
 .../alg.nonmodifying/mismatch/mismatch.pass.cpp        |  4 +++-
 .../alg.nonmodifying/mismatch/mismatch_pred.pass.cpp   |  4 +++-
 .../algorithms/alg.nonmodifying/nothing_to_do.pass.cpp |  4 +++-
 .../binary.search/binary_search.pass.cpp               |  4 +++-
 .../binary.search/binary_search_comp.pass.cpp          |  4 +++-
 .../alg.binary.search/equal.range/equal_range.pass.cpp |  4 +++-
 .../equal.range/equal_range_comp.pass.cpp              |  4 +++-
 .../alg.binary.search/lower.bound/lower_bound.pass.cpp |  4 +++-
 .../lower.bound/lower_bound_comp.pass.cpp              |  4 +++-
 .../alg.binary.search/nothing_to_do.pass.cpp           |  4 +++-
 .../alg.binary.search/upper.bound/upper_bound.pass.cpp |  4 +++-
 .../upper.bound/upper_bound_comp.pass.cpp              |  4 +++-
 .../alg.sorting/alg.clamp/clamp.comp.pass.cpp          |  4 +++-
 .../algorithms/alg.sorting/alg.clamp/clamp.pass.cpp    |  4 +++-
 .../alg.heap.operations/is.heap/is_heap.pass.cpp       |  4 +++-
 .../alg.heap.operations/is.heap/is_heap_comp.pass.cpp  |  4 +++-
 .../alg.heap.operations/is.heap/is_heap_until.pass.cpp |  4 +++-
 .../is.heap/is_heap_until_comp.pass.cpp                |  4 +++-
 .../alg.heap.operations/make.heap/make_heap.pass.cpp   |  4 +++-
 .../make.heap/make_heap_comp.pass.cpp                  |  4 +++-
 .../alg.heap.operations/nothing_to_do.pass.cpp         |  4 +++-
 .../alg.heap.operations/pop.heap/pop_heap.pass.cpp     |  4 +++-
 .../pop.heap/pop_heap_comp.pass.cpp                    |  4 +++-
 .../alg.heap.operations/push.heap/push_heap.pass.cpp   |  4 +++-
 .../push.heap/push_heap_comp.pass.cpp                  |  4 +++-
 .../alg.heap.operations/sort.heap/sort_heap.pass.cpp   |  4 +++-
 .../sort.heap/sort_heap_comp.pass.cpp                  |  4 +++-
 .../lexicographical_compare.pass.cpp                   |  4 +++-
 .../lexicographical_compare_comp.pass.cpp              |  4 +++-
 .../alg.sorting/alg.merge/inplace_merge.pass.cpp       |  4 +++-
 .../alg.sorting/alg.merge/inplace_merge_comp.pass.cpp  |  4 +++-
 .../algorithms/alg.sorting/alg.merge/merge.pass.cpp    |  4 +++-
 .../alg.sorting/alg.merge/merge_comp.pass.cpp          |  4 +++-
 .../algorithms/alg.sorting/alg.min.max/max.pass.cpp    |  4 +++-
 .../alg.sorting/alg.min.max/max_comp.pass.cpp          |  4 +++-
 .../alg.sorting/alg.min.max/max_element.pass.cpp       |  4 +++-
 .../alg.sorting/alg.min.max/max_element_comp.pass.cpp  |  4 +++-
 .../alg.sorting/alg.min.max/max_init_list.pass.cpp     |  4 +++-
 .../alg.min.max/max_init_list_comp.pass.cpp            |  4 +++-
 .../algorithms/alg.sorting/alg.min.max/min.pass.cpp    |  4 +++-
 .../alg.sorting/alg.min.max/min_comp.pass.cpp          |  4 +++-
 .../alg.sorting/alg.min.max/min_element.pass.cpp       |  4 +++-
 .../alg.sorting/alg.min.max/min_element_comp.pass.cpp  |  4 +++-
 .../alg.sorting/alg.min.max/min_init_list.pass.cpp     |  4 +++-
 .../alg.min.max/min_init_list_comp.pass.cpp            |  4 +++-
 .../algorithms/alg.sorting/alg.min.max/minmax.pass.cpp |  4 +++-
 .../alg.sorting/alg.min.max/minmax_comp.pass.cpp       |  4 +++-
 .../alg.sorting/alg.min.max/minmax_element.pass.cpp    |  4 +++-
 .../alg.min.max/minmax_element_comp.pass.cpp           |  4 +++-
 .../alg.sorting/alg.min.max/minmax_init_list.pass.cpp  |  4 +++-
 .../alg.min.max/minmax_init_list_comp.pass.cpp         |  4 +++-
 .../alg.min.max/requires_forward_iterator.fail.cpp     |  4 +++-
 .../alg.sorting/alg.nth.element/nth_element.pass.cpp   |  4 +++-
 .../alg.nth.element/nth_element_comp.pass.cpp          |  4 +++-
 .../next_permutation.pass.cpp                          |  4 +++-
 .../next_permutation_comp.pass.cpp                     |  4 +++-
 .../prev_permutation.pass.cpp                          |  4 +++-
 .../prev_permutation_comp.pass.cpp                     |  4 +++-
 .../alg.set.operations/includes/includes.pass.cpp      |  4 +++-
 .../alg.set.operations/includes/includes_comp.pass.cpp |  4 +++-
 .../alg.set.operations/nothing_to_do.pass.cpp          |  4 +++-
 .../set.difference/set_difference.pass.cpp             |  4 +++-
 .../set.difference/set_difference_comp.pass.cpp        |  4 +++-
 .../set.intersection/set_intersection.pass.cpp         |  4 +++-
 .../set.intersection/set_intersection_comp.pass.cpp    |  4 +++-
 .../set_symmetric_difference.pass.cpp                  |  4 +++-
 .../set_symmetric_difference_comp.pass.cpp             |  4 +++-
 .../alg.set.operations/set.union/set_union.pass.cpp    |  4 +++-
 .../set.union/set_union_comp.pass.cpp                  |  4 +++-
 .../set.union/set_union_move.pass.cpp                  |  4 +++-
 .../alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp  |  4 +++-
 .../alg.sort/is.sorted/is_sorted_comp.pass.cpp         |  4 +++-
 .../alg.sort/is.sorted/is_sorted_until.pass.cpp        |  4 +++-
 .../alg.sort/is.sorted/is_sorted_until_comp.pass.cpp   |  4 +++-
 .../alg.sorting/alg.sort/nothing_to_do.pass.cpp        |  4 +++-
 .../partial.sort.copy/partial_sort_copy.pass.cpp       |  4 +++-
 .../partial.sort.copy/partial_sort_copy_comp.pass.cpp  |  4 +++-
 .../alg.sort/partial.sort/partial_sort.pass.cpp        |  4 +++-
 .../alg.sort/partial.sort/partial_sort_comp.pass.cpp   |  4 +++-
 .../algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp |  4 +++-
 .../alg.sorting/alg.sort/sort/sort_comp.pass.cpp       |  4 +++-
 .../alg.sort/stable.sort/stable_sort.pass.cpp          |  4 +++-
 .../alg.sort/stable.sort/stable_sort_comp.pass.cpp     |  4 +++-
 test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp |  4 +++-
 .../algorithms.general/nothing_to_do.pass.cpp          |  4 +++-
 .../atomics.fences/atomic_signal_fence.pass.cpp        |  4 +++-
 .../atomics.fences/atomic_thread_fence.pass.cpp        |  4 +++-
 .../atomics/atomics.flag/atomic_flag_clear.pass.cpp    |  4 +++-
 .../atomics.flag/atomic_flag_clear_explicit.pass.cpp   |  4 +++-
 .../atomics.flag/atomic_flag_test_and_set.pass.cpp     |  4 +++-
 .../atomic_flag_test_and_set_explicit.pass.cpp         |  4 +++-
 test/std/atomics/atomics.flag/clear.pass.cpp           |  4 +++-
 test/std/atomics/atomics.flag/copy_assign.fail.cpp     |  4 +++-
 test/std/atomics/atomics.flag/copy_ctor.fail.cpp       |  4 +++-
 .../atomics/atomics.flag/copy_volatile_assign.fail.cpp |  4 +++-
 test/std/atomics/atomics.flag/default.pass.cpp         |  4 +++-
 test/std/atomics/atomics.flag/init.pass.cpp            |  4 +++-
 test/std/atomics/atomics.flag/test_and_set.pass.cpp    |  4 +++-
 .../std/atomics/atomics.general/nothing_to_do.pass.cpp |  4 +++-
 .../atomics.general/replace_failure_order.pass.cpp     |  2 +-
 .../atomics/atomics.lockfree/isalwayslockfree.pass.cpp |  2 +-
 test/std/atomics/atomics.lockfree/lockfree.pass.cpp    |  4 +++-
 .../std/atomics/atomics.order/kill_dependency.pass.cpp |  4 +++-
 test/std/atomics/atomics.order/memory_order.pass.cpp   |  4 +++-
 test/std/atomics/atomics.syn/nothing_to_do.pass.cpp    |  4 +++-
 .../std/atomics/atomics.types.generic/address.pass.cpp |  4 +++-
 test/std/atomics/atomics.types.generic/bool.pass.cpp   |  4 +++-
 .../atomics.types.generic/cstdint_typedefs.pass.cpp    |  4 +++-
 .../atomics/atomics.types.generic/integral.pass.cpp    |  4 +++-
 .../atomics.types.generic/integral_typedefs.pass.cpp   |  4 +++-
 .../atomics.types.generic/trivially_copyable.fail.cpp  |  4 +++-
 .../atomics.types.generic/trivially_copyable.pass.cpp  |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../atomic_compare_exchange_strong.pass.cpp            |  4 +++-
 .../atomic_compare_exchange_strong_explicit.pass.cpp   |  4 +++-
 .../atomic_compare_exchange_weak.pass.cpp              |  4 +++-
 .../atomic_compare_exchange_weak_explicit.pass.cpp     |  4 +++-
 .../atomic_exchange.pass.cpp                           |  4 +++-
 .../atomic_exchange_explicit.pass.cpp                  |  4 +++-
 .../atomic_fetch_add.pass.cpp                          |  4 +++-
 .../atomic_fetch_add_explicit.pass.cpp                 |  4 +++-
 .../atomic_fetch_and.pass.cpp                          |  4 +++-
 .../atomic_fetch_and_explicit.pass.cpp                 |  4 +++-
 .../atomic_fetch_or.pass.cpp                           |  4 +++-
 .../atomic_fetch_or_explicit.pass.cpp                  |  4 +++-
 .../atomic_fetch_sub.pass.cpp                          |  4 +++-
 .../atomic_fetch_sub_explicit.pass.cpp                 |  4 +++-
 .../atomic_fetch_xor.pass.cpp                          |  4 +++-
 .../atomic_fetch_xor_explicit.pass.cpp                 |  4 +++-
 .../atomics.types.operations.req/atomic_init.pass.cpp  |  4 +++-
 .../atomic_is_lock_free.pass.cpp                       |  4 +++-
 .../atomics.types.operations.req/atomic_load.pass.cpp  |  4 +++-
 .../atomic_load_explicit.pass.cpp                      |  4 +++-
 .../atomics.types.operations.req/atomic_store.pass.cpp |  4 +++-
 .../atomic_store_explicit.pass.cpp                     |  4 +++-
 .../atomic_var_init.pass.cpp                           |  4 +++-
 .../atomics.types.operations.req/ctor.pass.cpp         |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../atomics.types.operations/nothing_to_do.pass.cpp    |  4 +++-
 .../std/containers/associative/iterator_types.pass.cpp |  4 +++-
 .../map/PR28469_undefined_behavior_segfault.sh.cpp     |  4 +++-
 .../associative/map/allocator_mismatch.fail.cpp        |  4 +++-
 test/std/containers/associative/map/compare.pass.cpp   |  4 +++-
 .../containers/associative/map/gcc_workaround.pass.cpp |  5 +----
 .../associative/map/incomplete_type.pass.cpp           |  4 +++-
 .../containers/associative/map/map.access/at.pass.cpp  |  4 +++-
 .../associative/map/map.access/empty.fail.cpp          |  4 +++-
 .../associative/map/map.access/empty.pass.cpp          |  4 +++-
 .../associative/map/map.access/index_key.pass.cpp      |  4 +++-
 .../associative/map/map.access/index_rv_key.pass.cpp   |  4 +++-
 .../associative/map/map.access/index_tuple.pass.cpp    |  4 +++-
 .../associative/map/map.access/iterator.pass.cpp       |  4 +++-
 .../associative/map/map.access/max_size.pass.cpp       |  4 +++-
 .../associative/map/map.access/size.pass.cpp           |  4 +++-
 .../containers/associative/map/map.cons/alloc.pass.cpp |  4 +++-
 .../map/map.cons/assign_initializer_list.pass.cpp      |  4 +++-
 .../associative/map/map.cons/compare.pass.cpp          |  4 +++-
 .../associative/map/map.cons/compare_alloc.pass.cpp    |  4 +++-
 .../map/map.cons/compare_copy_constructible.fail.cpp   |  4 +++-
 .../containers/associative/map/map.cons/copy.pass.cpp  |  4 +++-
 .../associative/map/map.cons/copy_alloc.pass.cpp       |  4 +++-
 .../associative/map/map.cons/copy_assign.pass.cpp      |  4 +++-
 .../associative/map/map.cons/default.pass.cpp          |  4 +++-
 .../associative/map/map.cons/default_noexcept.pass.cpp |  4 +++-
 .../map/map.cons/default_recursive.pass.cpp            |  4 +++-
 .../associative/map/map.cons/dtor_noexcept.pass.cpp    |  4 +++-
 .../associative/map/map.cons/initializer_list.pass.cpp |  4 +++-
 .../map/map.cons/initializer_list_compare.pass.cpp     |  4 +++-
 .../map.cons/initializer_list_compare_alloc.pass.cpp   |  4 +++-
 .../associative/map/map.cons/iter_iter.pass.cpp        |  4 +++-
 .../associative/map/map.cons/iter_iter_comp.pass.cpp   |  4 +++-
 .../map/map.cons/iter_iter_comp_alloc.pass.cpp         |  4 +++-
 .../containers/associative/map/map.cons/move.pass.cpp  |  4 +++-
 .../associative/map/map.cons/move_alloc.pass.cpp       |  4 +++-
 .../associative/map/map.cons/move_assign.pass.cpp      |  4 +++-
 .../map/map.cons/move_assign_noexcept.pass.cpp         |  4 +++-
 .../associative/map/map.cons/move_noexcept.pass.cpp    |  4 +++-
 .../associative/map/map.erasure/erase_if.pass.cpp      |  4 +++-
 .../associative/map/map.modifiers/clear.pass.cpp       |  4 +++-
 .../associative/map/map.modifiers/emplace.pass.cpp     |  4 +++-
 .../map/map.modifiers/emplace_hint.pass.cpp            |  4 +++-
 .../associative/map/map.modifiers/erase_iter.pass.cpp  |  4 +++-
 .../map/map.modifiers/erase_iter_iter.pass.cpp         |  4 +++-
 .../associative/map/map.modifiers/erase_key.pass.cpp   |  4 +++-
 .../map/map.modifiers/extract_iterator.pass.cpp        |  4 +++-
 .../associative/map/map.modifiers/extract_key.pass.cpp |  4 +++-
 .../insert_and_emplace_allocator_requirements.pass.cpp |  4 +++-
 .../associative/map/map.modifiers/insert_cv.pass.cpp   |  4 +++-
 .../map/map.modifiers/insert_initializer_list.pass.cpp |  4 +++-
 .../map/map.modifiers/insert_iter_cv.pass.cpp          |  4 +++-
 .../map/map.modifiers/insert_iter_iter.pass.cpp        |  4 +++-
 .../map/map.modifiers/insert_iter_rv.pass.cpp          |  4 +++-
 .../map/map.modifiers/insert_node_type.pass.cpp        |  4 +++-
 .../map/map.modifiers/insert_node_type_hint.pass.cpp   |  4 +++-
 .../map/map.modifiers/insert_or_assign.pass.cpp        |  4 +++-
 .../associative/map/map.modifiers/insert_rv.pass.cpp   |  4 +++-
 .../associative/map/map.modifiers/merge.pass.cpp       |  3 ++-
 .../associative/map/map.modifiers/try.emplace.pass.cpp |  4 +++-
 .../containers/associative/map/map.ops/count.pass.cpp  |  4 +++-
 .../containers/associative/map/map.ops/count0.pass.cpp |  4 +++-
 .../containers/associative/map/map.ops/count1.fail.cpp |  2 +-
 .../containers/associative/map/map.ops/count2.fail.cpp |  2 +-
 .../containers/associative/map/map.ops/count3.fail.cpp |  2 +-
 .../associative/map/map.ops/count_transparent.pass.cpp |  4 +++-
 .../associative/map/map.ops/equal_range.pass.cpp       |  4 +++-
 .../associative/map/map.ops/equal_range0.pass.cpp      |  4 +++-
 .../associative/map/map.ops/equal_range1.fail.cpp      |  2 +-
 .../associative/map/map.ops/equal_range2.fail.cpp      |  2 +-
 .../associative/map/map.ops/equal_range3.fail.cpp      |  2 +-
 .../map/map.ops/equal_range_transparent.pass.cpp       |  4 +++-
 .../containers/associative/map/map.ops/find.pass.cpp   |  4 +++-
 .../containers/associative/map/map.ops/find0.pass.cpp  |  4 +++-
 .../containers/associative/map/map.ops/find1.fail.cpp  |  2 +-
 .../containers/associative/map/map.ops/find2.fail.cpp  |  2 +-
 .../containers/associative/map/map.ops/find3.fail.cpp  |  2 +-
 .../associative/map/map.ops/lower_bound.pass.cpp       |  4 +++-
 .../associative/map/map.ops/lower_bound0.pass.cpp      |  4 +++-
 .../associative/map/map.ops/lower_bound1.fail.cpp      |  2 +-
 .../associative/map/map.ops/lower_bound2.fail.cpp      |  2 +-
 .../associative/map/map.ops/lower_bound3.fail.cpp      |  2 +-
 .../associative/map/map.ops/upper_bound.pass.cpp       |  4 +++-
 .../associative/map/map.ops/upper_bound0.pass.cpp      |  4 +++-
 .../associative/map/map.ops/upper_bound1.fail.cpp      |  2 +-
 .../associative/map/map.ops/upper_bound2.fail.cpp      |  2 +-
 .../associative/map/map.ops/upper_bound3.fail.cpp      |  2 +-
 .../associative/map/map.special/member_swap.pass.cpp   |  4 +++-
 .../map/map.special/non_member_swap.pass.cpp           |  4 +++-
 .../associative/map/map.special/swap_noexcept.pass.cpp |  4 +++-
 test/std/containers/associative/map/types.pass.cpp     |  4 +++-
 .../associative/multimap/allocator_mismatch.fail.cpp   |  4 +++-
 .../std/containers/associative/multimap/empty.fail.cpp |  4 +++-
 .../std/containers/associative/multimap/empty.pass.cpp |  4 +++-
 .../associative/multimap/incomplete_type.pass.cpp      |  4 +++-
 .../containers/associative/multimap/iterator.pass.cpp  |  4 +++-
 .../containers/associative/multimap/max_size.pass.cpp  |  4 +++-
 .../associative/multimap/multimap.cons/alloc.pass.cpp  |  4 +++-
 .../multimap.cons/assign_initializer_list.pass.cpp     |  4 +++-
 .../multimap/multimap.cons/compare.pass.cpp            |  4 +++-
 .../multimap/multimap.cons/compare_alloc.pass.cpp      |  4 +++-
 .../multimap.cons/compare_copy_constructible.fail.cpp  |  4 +++-
 .../associative/multimap/multimap.cons/copy.pass.cpp   |  4 +++-
 .../multimap/multimap.cons/copy_alloc.pass.cpp         |  4 +++-
 .../multimap/multimap.cons/copy_assign.pass.cpp        |  4 +++-
 .../multimap/multimap.cons/default.pass.cpp            |  4 +++-
 .../multimap/multimap.cons/default_noexcept.pass.cpp   |  4 +++-
 .../multimap/multimap.cons/default_recursive.pass.cpp  |  4 +++-
 .../multimap/multimap.cons/dtor_noexcept.pass.cpp      |  4 +++-
 .../multimap/multimap.cons/initializer_list.pass.cpp   |  4 +++-
 .../multimap.cons/initializer_list_compare.pass.cpp    |  4 +++-
 .../initializer_list_compare_alloc.pass.cpp            |  4 +++-
 .../multimap/multimap.cons/iter_iter.pass.cpp          |  4 +++-
 .../multimap/multimap.cons/iter_iter_comp.pass.cpp     |  4 +++-
 .../multimap.cons/iter_iter_comp_alloc.pass.cpp        |  4 +++-
 .../associative/multimap/multimap.cons/move.pass.cpp   |  4 +++-
 .../multimap/multimap.cons/move_alloc.pass.cpp         |  4 +++-
 .../multimap/multimap.cons/move_assign.pass.cpp        |  4 +++-
 .../multimap.cons/move_assign_noexcept.pass.cpp        |  4 +++-
 .../multimap/multimap.cons/move_noexcept.pass.cpp      |  4 +++-
 .../multimap/multimap.erasure/erase_if.pass.cpp        |  4 +++-
 .../multimap/multimap.modifiers/clear.pass.cpp         |  4 +++-
 .../multimap/multimap.modifiers/emplace.pass.cpp       |  4 +++-
 .../multimap/multimap.modifiers/emplace_hint.pass.cpp  |  4 +++-
 .../multimap/multimap.modifiers/erase_iter.pass.cpp    |  4 +++-
 .../multimap.modifiers/erase_iter_iter.pass.cpp        |  4 +++-
 .../multimap/multimap.modifiers/erase_key.pass.cpp     |  4 +++-
 .../multimap.modifiers/extract_iterator.pass.cpp       |  4 +++-
 .../multimap/multimap.modifiers/extract_key.pass.cpp   |  4 +++-
 .../insert_allocator_requirements.pass.cpp             |  4 +++-
 .../multimap/multimap.modifiers/insert_cv.pass.cpp     |  4 +++-
 .../insert_initializer_list.pass.cpp                   |  4 +++-
 .../multimap.modifiers/insert_iter_cv.pass.cpp         |  4 +++-
 .../multimap.modifiers/insert_iter_iter.pass.cpp       |  4 +++-
 .../multimap.modifiers/insert_iter_rv.pass.cpp         |  4 +++-
 .../multimap.modifiers/insert_node_type.pass.cpp       |  4 +++-
 .../multimap.modifiers/insert_node_type_hint.pass.cpp  |  4 +++-
 .../multimap/multimap.modifiers/insert_rv.pass.cpp     |  4 +++-
 .../multimap/multimap.modifiers/merge.pass.cpp         |  3 ++-
 .../associative/multimap/multimap.ops/count.pass.cpp   |  4 +++-
 .../associative/multimap/multimap.ops/count0.pass.cpp  |  4 +++-
 .../associative/multimap/multimap.ops/count1.fail.cpp  |  2 +-
 .../associative/multimap/multimap.ops/count2.fail.cpp  |  2 +-
 .../associative/multimap/multimap.ops/count3.fail.cpp  |  2 +-
 .../multimap/multimap.ops/count_transparent.pass.cpp   |  4 +++-
 .../multimap/multimap.ops/equal_range.pass.cpp         |  4 +++-
 .../multimap/multimap.ops/equal_range0.pass.cpp        |  4 +++-
 .../multimap/multimap.ops/equal_range1.fail.cpp        |  2 +-
 .../multimap/multimap.ops/equal_range2.fail.cpp        |  2 +-
 .../multimap/multimap.ops/equal_range3.fail.cpp        |  2 +-
 .../multimap.ops/equal_range_transparent.pass.cpp      |  4 +++-
 .../associative/multimap/multimap.ops/find.pass.cpp    |  4 +++-
 .../associative/multimap/multimap.ops/find0.pass.cpp   |  4 +++-
 .../associative/multimap/multimap.ops/find1.fail.cpp   |  2 +-
 .../associative/multimap/multimap.ops/find2.fail.cpp   |  2 +-
 .../associative/multimap/multimap.ops/find3.fail.cpp   |  2 +-
 .../multimap/multimap.ops/lower_bound.pass.cpp         |  4 +++-
 .../multimap/multimap.ops/lower_bound0.pass.cpp        |  4 +++-
 .../multimap/multimap.ops/lower_bound1.fail.cpp        |  2 +-
 .../multimap/multimap.ops/lower_bound2.fail.cpp        |  2 +-
 .../multimap/multimap.ops/lower_bound3.fail.cpp        |  2 +-
 .../multimap/multimap.ops/upper_bound.pass.cpp         |  4 +++-
 .../multimap/multimap.ops/upper_bound0.pass.cpp        |  4 +++-
 .../multimap/multimap.ops/upper_bound1.fail.cpp        |  2 +-
 .../multimap/multimap.ops/upper_bound2.fail.cpp        |  2 +-
 .../multimap/multimap.ops/upper_bound3.fail.cpp        |  2 +-
 .../multimap/multimap.special/member_swap.pass.cpp     |  4 +++-
 .../multimap/multimap.special/non_member_swap.pass.cpp |  4 +++-
 .../multimap/multimap.special/swap_noexcept.pass.cpp   |  4 +++-
 .../std/containers/associative/multimap/scary.pass.cpp |  4 +++-
 test/std/containers/associative/multimap/size.pass.cpp |  4 +++-
 .../std/containers/associative/multimap/types.pass.cpp |  4 +++-
 .../associative/multiset/allocator_mismatch.fail.cpp   |  4 +++-
 .../std/containers/associative/multiset/clear.pass.cpp |  4 +++-
 .../std/containers/associative/multiset/count.pass.cpp |  4 +++-
 .../associative/multiset/count_transparent.pass.cpp    |  4 +++-
 .../containers/associative/multiset/emplace.pass.cpp   |  4 +++-
 .../associative/multiset/emplace_hint.pass.cpp         |  4 +++-
 .../std/containers/associative/multiset/empty.fail.cpp |  4 +++-
 .../std/containers/associative/multiset/empty.pass.cpp |  4 +++-
 .../associative/multiset/equal_range.pass.cpp          |  4 +++-
 .../multiset/equal_range_transparent.pass.cpp          |  4 +++-
 .../associative/multiset/erase_iter.pass.cpp           |  4 +++-
 .../associative/multiset/erase_iter_iter.pass.cpp      |  4 +++-
 .../containers/associative/multiset/erase_key.pass.cpp |  4 +++-
 .../associative/multiset/extract_iterator.pass.cpp     |  4 +++-
 .../associative/multiset/extract_key.pass.cpp          |  4 +++-
 test/std/containers/associative/multiset/find.pass.cpp |  4 +++-
 .../associative/multiset/incomplete_type.pass.cpp      |  4 +++-
 .../containers/associative/multiset/insert_cv.pass.cpp |  4 +++-
 .../insert_emplace_allocator_requirements.pass.cpp     |  4 +++-
 .../multiset/insert_initializer_list.pass.cpp          |  4 +++-
 .../associative/multiset/insert_iter_cv.pass.cpp       |  4 +++-
 .../associative/multiset/insert_iter_iter.pass.cpp     |  4 +++-
 .../associative/multiset/insert_iter_rv.pass.cpp       |  4 +++-
 .../associative/multiset/insert_node_type.pass.cpp     |  4 +++-
 .../multiset/insert_node_type_hint.pass.cpp            |  4 +++-
 .../containers/associative/multiset/insert_rv.pass.cpp |  4 +++-
 .../containers/associative/multiset/iterator.pass.cpp  |  4 +++-
 .../associative/multiset/lower_bound.pass.cpp          |  4 +++-
 .../containers/associative/multiset/max_size.pass.cpp  |  4 +++-
 .../std/containers/associative/multiset/merge.pass.cpp |  3 ++-
 .../associative/multiset/multiset.cons/alloc.pass.cpp  |  4 +++-
 .../multiset.cons/assign_initializer_list.pass.cpp     |  4 +++-
 .../multiset/multiset.cons/compare.pass.cpp            |  4 +++-
 .../multiset/multiset.cons/compare_alloc.pass.cpp      |  4 +++-
 .../multiset.cons/compare_copy_constructible.fail.cpp  |  4 +++-
 .../associative/multiset/multiset.cons/copy.pass.cpp   |  4 +++-
 .../multiset/multiset.cons/copy_alloc.pass.cpp         |  4 +++-
 .../multiset/multiset.cons/copy_assign.pass.cpp        |  4 +++-
 .../multiset/multiset.cons/default.pass.cpp            |  4 +++-
 .../multiset/multiset.cons/default_noexcept.pass.cpp   |  4 +++-
 .../multiset/multiset.cons/dtor_noexcept.pass.cpp      |  4 +++-
 .../multiset/multiset.cons/initializer_list.pass.cpp   |  4 +++-
 .../multiset.cons/initializer_list_compare.pass.cpp    |  4 +++-
 .../initializer_list_compare_alloc.pass.cpp            |  4 +++-
 .../multiset/multiset.cons/iter_iter.pass.cpp          |  4 +++-
 .../multiset/multiset.cons/iter_iter_alloc.pass.cpp    |  4 +++-
 .../multiset/multiset.cons/iter_iter_comp.pass.cpp     |  4 +++-
 .../associative/multiset/multiset.cons/move.pass.cpp   |  4 +++-
 .../multiset/multiset.cons/move_alloc.pass.cpp         |  4 +++-
 .../multiset/multiset.cons/move_assign.pass.cpp        |  4 +++-
 .../multiset.cons/move_assign_noexcept.pass.cpp        |  4 +++-
 .../multiset/multiset.cons/move_noexcept.pass.cpp      |  4 +++-
 .../multiset/multiset.erasure/erase_if.pass.cpp        |  4 +++-
 .../multiset/multiset.special/member_swap.pass.cpp     |  4 +++-
 .../multiset/multiset.special/non_member_swap.pass.cpp |  4 +++-
 .../multiset/multiset.special/swap_noexcept.pass.cpp   |  4 +++-
 .../std/containers/associative/multiset/scary.pass.cpp |  4 +++-
 test/std/containers/associative/multiset/size.pass.cpp |  4 +++-
 .../std/containers/associative/multiset/types.pass.cpp |  4 +++-
 .../associative/multiset/upper_bound.pass.cpp          |  4 +++-
 .../associative/set/allocator_mismatch.fail.cpp        |  4 +++-
 test/std/containers/associative/set/clear.pass.cpp     |  4 +++-
 test/std/containers/associative/set/count.pass.cpp     |  4 +++-
 .../associative/set/count_transparent.pass.cpp         |  4 +++-
 test/std/containers/associative/set/emplace.pass.cpp   |  4 +++-
 .../containers/associative/set/emplace_hint.pass.cpp   |  4 +++-
 test/std/containers/associative/set/empty.fail.cpp     |  4 +++-
 test/std/containers/associative/set/empty.pass.cpp     |  4 +++-
 .../containers/associative/set/equal_range.pass.cpp    |  4 +++-
 .../associative/set/equal_range_transparent.pass.cpp   |  4 +++-
 .../std/containers/associative/set/erase_iter.pass.cpp |  4 +++-
 .../associative/set/erase_iter_iter.pass.cpp           |  4 +++-
 test/std/containers/associative/set/erase_key.pass.cpp |  4 +++-
 .../associative/set/extract_iterator.pass.cpp          |  4 +++-
 .../containers/associative/set/extract_key.pass.cpp    |  4 +++-
 test/std/containers/associative/set/find.pass.cpp      |  4 +++-
 .../containers/associative/set/gcc_workaround.pass.cpp |  5 +----
 .../associative/set/incomplete_type.pass.cpp           |  4 +++-
 .../insert_and_emplace_allocator_requirements.pass.cpp |  4 +++-
 test/std/containers/associative/set/insert_cv.pass.cpp |  4 +++-
 .../associative/set/insert_initializer_list.pass.cpp   |  4 +++-
 .../containers/associative/set/insert_iter_cv.pass.cpp |  4 +++-
 .../associative/set/insert_iter_iter.pass.cpp          |  4 +++-
 .../containers/associative/set/insert_iter_rv.pass.cpp |  4 +++-
 .../associative/set/insert_node_type.pass.cpp          |  4 +++-
 .../associative/set/insert_node_type_hint.pass.cpp     |  4 +++-
 test/std/containers/associative/set/insert_rv.pass.cpp |  4 +++-
 test/std/containers/associative/set/iterator.pass.cpp  |  4 +++-
 .../containers/associative/set/lower_bound.pass.cpp    |  4 +++-
 test/std/containers/associative/set/max_size.pass.cpp  |  4 +++-
 test/std/containers/associative/set/merge.pass.cpp     |  3 ++-
 .../containers/associative/set/set.cons/alloc.pass.cpp |  4 +++-
 .../set/set.cons/assign_initializer_list.pass.cpp      |  4 +++-
 .../associative/set/set.cons/compare.pass.cpp          |  4 +++-
 .../associative/set/set.cons/compare_alloc.pass.cpp    |  4 +++-
 .../set/set.cons/compare_copy_constructible.fail.cpp   |  4 +++-
 .../containers/associative/set/set.cons/copy.pass.cpp  |  4 +++-
 .../associative/set/set.cons/copy_alloc.pass.cpp       |  4 +++-
 .../associative/set/set.cons/copy_assign.pass.cpp      |  4 +++-
 .../associative/set/set.cons/default.pass.cpp          |  4 +++-
 .../associative/set/set.cons/default_noexcept.pass.cpp |  4 +++-
 .../associative/set/set.cons/dtor_noexcept.pass.cpp    |  4 +++-
 .../associative/set/set.cons/initializer_list.pass.cpp |  4 +++-
 .../set/set.cons/initializer_list_compare.pass.cpp     |  4 +++-
 .../set.cons/initializer_list_compare_alloc.pass.cpp   |  4 +++-
 .../associative/set/set.cons/iter_iter.pass.cpp        |  4 +++-
 .../associative/set/set.cons/iter_iter_alloc.pass.cpp  |  4 +++-
 .../associative/set/set.cons/iter_iter_comp.pass.cpp   |  4 +++-
 .../containers/associative/set/set.cons/move.pass.cpp  |  4 +++-
 .../associative/set/set.cons/move_alloc.pass.cpp       |  4 +++-
 .../associative/set/set.cons/move_assign.pass.cpp      |  4 +++-
 .../set/set.cons/move_assign_noexcept.pass.cpp         |  4 +++-
 .../associative/set/set.cons/move_noexcept.pass.cpp    |  4 +++-
 .../associative/set/set.erasure/erase_if.pass.cpp      |  4 +++-
 .../associative/set/set.special/member_swap.pass.cpp   |  4 +++-
 .../set/set.special/non_member_swap.pass.cpp           |  4 +++-
 .../associative/set/set.special/swap_noexcept.pass.cpp |  4 +++-
 test/std/containers/associative/set/size.pass.cpp      |  4 +++-
 test/std/containers/associative/set/types.pass.cpp     |  4 +++-
 .../containers/associative/set/upper_bound.pass.cpp    |  4 +++-
 .../container.adaptors/nothing_to_do.pass.cpp          |  4 +++-
 .../priqueue.cons.alloc/ctor_alloc.pass.cpp            |  4 +++-
 .../priqueue.cons.alloc/ctor_comp_alloc.pass.cpp       |  4 +++-
 .../priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp  |  4 +++-
 .../priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp |  4 +++-
 .../priqueue.cons.alloc/ctor_copy_alloc.pass.cpp       |  4 +++-
 .../priqueue.cons.alloc/ctor_move_alloc.pass.cpp       |  4 +++-
 .../priority.queue/priqueue.cons/assign_copy.pass.cpp  |  4 +++-
 .../priority.queue/priqueue.cons/assign_move.pass.cpp  |  4 +++-
 .../priority.queue/priqueue.cons/ctor_comp.pass.cpp    |  4 +++-
 .../priqueue.cons/ctor_comp_container.pass.cpp         |  4 +++-
 .../priqueue.cons/ctor_comp_rcontainer.pass.cpp        |  4 +++-
 .../priority.queue/priqueue.cons/ctor_copy.pass.cpp    |  4 +++-
 .../priority.queue/priqueue.cons/ctor_default.pass.cpp |  4 +++-
 .../priqueue.cons/ctor_iter_iter.pass.cpp              |  4 +++-
 .../priqueue.cons/ctor_iter_iter_comp.pass.cpp         |  4 +++-
 .../priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp    |  4 +++-
 .../priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp   |  4 +++-
 .../priority.queue/priqueue.cons/ctor_move.pass.cpp    |  4 +++-
 .../priority.queue/priqueue.cons/deduct.fail.cpp       |  4 +++-
 .../priority.queue/priqueue.cons/deduct.pass.cpp       |  4 +++-
 .../priqueue.cons/default_noexcept.pass.cpp            |  4 +++-
 .../priqueue.cons/dtor_noexcept.pass.cpp               |  4 +++-
 .../priqueue.cons/move_assign_noexcept.pass.cpp        |  4 +++-
 .../priqueue.cons/move_noexcept.pass.cpp               |  4 +++-
 .../priority.queue/priqueue.members/emplace.pass.cpp   |  4 +++-
 .../priority.queue/priqueue.members/empty.fail.cpp     |  4 +++-
 .../priority.queue/priqueue.members/empty.pass.cpp     |  4 +++-
 .../priority.queue/priqueue.members/pop.pass.cpp       |  4 +++-
 .../priority.queue/priqueue.members/push.pass.cpp      |  4 +++-
 .../priqueue.members/push_rvalue.pass.cpp              |  4 +++-
 .../priority.queue/priqueue.members/size.pass.cpp      |  4 +++-
 .../priority.queue/priqueue.members/swap.pass.cpp      |  4 +++-
 .../priority.queue/priqueue.members/top.pass.cpp       |  4 +++-
 .../priority.queue/priqueue.special/swap.pass.cpp      |  4 +++-
 .../priqueue.special/swap_noexcept.pass.cpp            |  4 +++-
 .../container.adaptors/priority.queue/types.fail.cpp   |  4 +++-
 .../container.adaptors/priority.queue/types.pass.cpp   |  4 +++-
 .../queue/queue.cons.alloc/ctor_alloc.pass.cpp         |  4 +++-
 .../queue.cons.alloc/ctor_container_alloc.pass.cpp     |  4 +++-
 .../queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp   |  4 +++-
 .../queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp    |  4 +++-
 .../queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp  |  4 +++-
 .../queue/queue.cons/ctor_container.pass.cpp           |  4 +++-
 .../queue/queue.cons/ctor_copy.pass.cpp                |  4 +++-
 .../queue/queue.cons/ctor_default.pass.cpp             |  4 +++-
 .../queue/queue.cons/ctor_move.pass.cpp                |  4 +++-
 .../queue/queue.cons/ctor_rcontainer.pass.cpp          |  4 +++-
 .../queue/queue.cons/deduct.fail.cpp                   |  4 +++-
 .../queue/queue.cons/deduct.pass.cpp                   |  4 +++-
 .../queue/queue.cons/default_noexcept.pass.cpp         |  4 +++-
 .../queue/queue.cons/dtor_noexcept.pass.cpp            |  4 +++-
 .../queue/queue.cons/move_assign_noexcept.pass.cpp     |  4 +++-
 .../queue/queue.cons/move_noexcept.pass.cpp            |  4 +++-
 .../queue/queue.defn/assign_copy.pass.cpp              |  4 +++-
 .../queue/queue.defn/assign_move.pass.cpp              |  4 +++-
 .../container.adaptors/queue/queue.defn/back.pass.cpp  |  4 +++-
 .../queue/queue.defn/back_const.pass.cpp               |  4 +++-
 .../queue/queue.defn/emplace.pass.cpp                  |  4 +++-
 .../container.adaptors/queue/queue.defn/empty.fail.cpp |  4 +++-
 .../container.adaptors/queue/queue.defn/empty.pass.cpp |  4 +++-
 .../container.adaptors/queue/queue.defn/front.pass.cpp |  4 +++-
 .../queue/queue.defn/front_const.pass.cpp              |  4 +++-
 .../container.adaptors/queue/queue.defn/pop.pass.cpp   |  4 +++-
 .../container.adaptors/queue/queue.defn/push.pass.cpp  |  4 +++-
 .../queue/queue.defn/push_rv.pass.cpp                  |  4 +++-
 .../container.adaptors/queue/queue.defn/size.pass.cpp  |  4 +++-
 .../container.adaptors/queue/queue.defn/swap.pass.cpp  |  4 +++-
 .../container.adaptors/queue/queue.defn/types.fail.cpp |  4 +++-
 .../container.adaptors/queue/queue.defn/types.pass.cpp |  4 +++-
 .../container.adaptors/queue/queue.ops/eq.pass.cpp     |  4 +++-
 .../container.adaptors/queue/queue.ops/lt.pass.cpp     |  4 +++-
 .../queue/queue.special/swap.pass.cpp                  |  4 +++-
 .../queue/queue.special/swap_noexcept.pass.cpp         |  4 +++-
 .../stack/stack.cons.alloc/ctor_alloc.pass.cpp         |  4 +++-
 .../stack.cons.alloc/ctor_container_alloc.pass.cpp     |  4 +++-
 .../stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp    |  4 +++-
 .../stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp    |  4 +++-
 .../stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp  |  4 +++-
 .../stack/stack.cons/ctor_container.pass.cpp           |  4 +++-
 .../stack/stack.cons/ctor_copy.pass.cpp                |  4 +++-
 .../stack/stack.cons/ctor_default.pass.cpp             |  4 +++-
 .../stack/stack.cons/ctor_move.pass.cpp                |  4 +++-
 .../stack/stack.cons/ctor_rcontainer.pass.cpp          |  4 +++-
 .../stack/stack.cons/deduct.fail.cpp                   |  4 +++-
 .../stack/stack.cons/deduct.pass.cpp                   |  4 +++-
 .../stack/stack.cons/default_noexcept.pass.cpp         |  4 +++-
 .../stack/stack.cons/dtor_noexcept.pass.cpp            |  4 +++-
 .../stack/stack.cons/move_assign_noexcept.pass.cpp     |  4 +++-
 .../stack/stack.cons/move_noexcept.pass.cpp            |  4 +++-
 .../stack/stack.defn/assign_copy.pass.cpp              |  4 +++-
 .../stack/stack.defn/assign_move.pass.cpp              |  4 +++-
 .../stack/stack.defn/emplace.pass.cpp                  |  4 +++-
 .../container.adaptors/stack/stack.defn/empty.fail.cpp |  4 +++-
 .../container.adaptors/stack/stack.defn/empty.pass.cpp |  4 +++-
 .../container.adaptors/stack/stack.defn/pop.pass.cpp   |  4 +++-
 .../container.adaptors/stack/stack.defn/push.pass.cpp  |  4 +++-
 .../stack/stack.defn/push_rv.pass.cpp                  |  4 +++-
 .../container.adaptors/stack/stack.defn/size.pass.cpp  |  4 +++-
 .../container.adaptors/stack/stack.defn/swap.pass.cpp  |  4 +++-
 .../container.adaptors/stack/stack.defn/top.pass.cpp   |  4 +++-
 .../stack/stack.defn/top_const.pass.cpp                |  4 +++-
 .../container.adaptors/stack/stack.defn/types.fail.cpp |  4 +++-
 .../container.adaptors/stack/stack.defn/types.pass.cpp |  4 +++-
 .../container.adaptors/stack/stack.ops/eq.pass.cpp     |  4 +++-
 .../container.adaptors/stack/stack.ops/lt.pass.cpp     |  4 +++-
 .../stack/stack.special/swap.pass.cpp                  |  4 +++-
 .../stack/stack.special/swap_noexcept.pass.cpp         |  4 +++-
 .../std/containers/container.node/node_handle.pass.cpp |  4 +++-
 .../associative.reqmts.except/nothing_to_do.pass.cpp   |  4 +++-
 .../associative.reqmts/nothing_to_do.pass.cpp          |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../allocator_move.pass.cpp                            |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../container.requirements/nothing_to_do.pass.cpp      |  4 +++-
 .../sequence.reqmts/nothing_to_do.pass.cpp             |  4 +++-
 .../unord.req/nothing_to_do.pass.cpp                   |  4 +++-
 .../unord.req/unord.req.except/nothing_to_do.pass.cpp  |  4 +++-
 .../containers.general/nothing_to_do.pass.cpp          |  4 +++-
 test/std/containers/nothing_to_do.pass.cpp             |  4 +++-
 .../sequences/array/array.cons/deduct.fail.cpp         |  4 +++-
 .../sequences/array/array.cons/deduct.pass.cpp         |  4 +++-
 .../sequences/array/array.cons/default.pass.cpp        |  4 +++-
 .../sequences/array/array.cons/implicit_copy.pass.cpp  |  4 +++-
 .../array/array.cons/initializer_list.pass.cpp         |  4 +++-
 .../sequences/array/array.data/data.pass.cpp           |  4 +++-
 .../sequences/array/array.data/data_const.pass.cpp     |  4 +++-
 .../sequences/array/array.fill/fill.fail.cpp           |  4 +++-
 .../sequences/array/array.fill/fill.pass.cpp           |  4 +++-
 .../sequences/array/array.size/size.pass.cpp           |  4 +++-
 .../sequences/array/array.special/swap.pass.cpp        |  4 +++-
 .../sequences/array/array.swap/swap.fail.cpp           |  4 +++-
 .../sequences/array/array.swap/swap.pass.cpp           |  4 +++-
 .../sequences/array/array.tuple/get.fail.cpp           |  4 +++-
 .../sequences/array/array.tuple/get.pass.cpp           |  4 +++-
 .../sequences/array/array.tuple/get_const.pass.cpp     |  4 +++-
 .../sequences/array/array.tuple/get_const_rv.pass.cpp  |  4 +++-
 .../sequences/array/array.tuple/get_rv.pass.cpp        |  4 +++-
 .../sequences/array/array.tuple/tuple_element.fail.cpp |  4 +++-
 .../sequences/array/array.tuple/tuple_element.pass.cpp |  4 +++-
 .../sequences/array/array.tuple/tuple_size.pass.cpp    |  4 +++-
 .../array/array.zero/tested_elsewhere.pass.cpp         |  4 +++-
 test/std/containers/sequences/array/at.pass.cpp        |  4 +++-
 test/std/containers/sequences/array/begin.pass.cpp     |  4 +++-
 test/std/containers/sequences/array/compare.fail.cpp   |  4 +++-
 test/std/containers/sequences/array/compare.pass.cpp   |  4 +++-
 .../std/containers/sequences/array/contiguous.pass.cpp |  4 +++-
 test/std/containers/sequences/array/empty.fail.cpp     |  4 +++-
 test/std/containers/sequences/array/empty.pass.cpp     |  4 +++-
 .../std/containers/sequences/array/front_back.pass.cpp |  4 +++-
 test/std/containers/sequences/array/indexing.pass.cpp  |  4 +++-
 test/std/containers/sequences/array/iterators.pass.cpp |  4 +++-
 test/std/containers/sequences/array/max_size.pass.cpp  |  4 +++-
 .../sequences/array/size_and_alignment.pass.cpp        |  6 +++++-
 test/std/containers/sequences/array/types.pass.cpp     |  4 +++-
 .../sequences/deque/allocator_mismatch.fail.cpp        |  4 +++-
 .../sequences/deque/deque.capacity/access.pass.cpp     |  4 +++-
 .../sequences/deque/deque.capacity/empty.fail.cpp      |  4 +++-
 .../sequences/deque/deque.capacity/empty.pass.cpp      |  4 +++-
 .../sequences/deque/deque.capacity/max_size.pass.cpp   |  4 +++-
 .../deque/deque.capacity/resize_size.pass.cpp          |  4 +++-
 .../deque/deque.capacity/resize_size_value.pass.cpp    |  4 +++-
 .../deque/deque.capacity/shrink_to_fit.pass.cpp        |  4 +++-
 .../sequences/deque/deque.capacity/size.pass.cpp       |  4 +++-
 .../sequences/deque/deque.cons/alloc.pass.cpp          |  4 +++-
 .../deque/deque.cons/assign_initializer_list.pass.cpp  |  4 +++-
 .../deque/deque.cons/assign_iter_iter.pass.cpp         |  4 +++-
 .../deque/deque.cons/assign_size_value.pass.cpp        |  4 +++-
 .../sequences/deque/deque.cons/copy.pass.cpp           |  4 +++-
 .../sequences/deque/deque.cons/copy_alloc.pass.cpp     |  4 +++-
 .../sequences/deque/deque.cons/deduct.fail.cpp         |  4 +++-
 .../sequences/deque/deque.cons/deduct.pass.cpp         |  4 +++-
 .../sequences/deque/deque.cons/default.pass.cpp        |  4 +++-
 .../deque/deque.cons/default_noexcept.pass.cpp         |  4 +++-
 .../sequences/deque/deque.cons/dtor_noexcept.pass.cpp  |  4 +++-
 .../deque/deque.cons/initializer_list.pass.cpp         |  4 +++-
 .../deque/deque.cons/initializer_list_alloc.pass.cpp   |  4 +++-
 .../sequences/deque/deque.cons/iter_iter.pass.cpp      |  4 +++-
 .../deque/deque.cons/iter_iter_alloc.pass.cpp          |  4 +++-
 .../sequences/deque/deque.cons/move.pass.cpp           |  4 +++-
 .../sequences/deque/deque.cons/move_alloc.pass.cpp     |  4 +++-
 .../sequences/deque/deque.cons/move_assign.pass.cpp    |  4 +++-
 .../deque/deque.cons/move_assign_noexcept.pass.cpp     |  4 +++-
 .../sequences/deque/deque.cons/move_noexcept.pass.cpp  |  4 +++-
 .../sequences/deque/deque.cons/op_equal.pass.cpp       |  4 +++-
 .../deque.cons/op_equal_initializer_list.pass.cpp      |  4 +++-
 .../sequences/deque/deque.cons/size.pass.cpp           |  4 +++-
 .../sequences/deque/deque.cons/size_value.pass.cpp     |  4 +++-
 .../deque/deque.cons/size_value_alloc.pass.cpp         |  4 +++-
 .../sequences/deque/deque.erasure/erase.pass.cpp       |  4 +++-
 .../sequences/deque/deque.erasure/erase_if.pass.cpp    |  4 +++-
 .../sequences/deque/deque.modifiers/clear.pass.cpp     |  4 +++-
 .../sequences/deque/deque.modifiers/emplace.pass.cpp   |  4 +++-
 .../deque/deque.modifiers/emplace_back.pass.cpp        |  4 +++-
 .../deque/deque.modifiers/emplace_front.pass.cpp       |  4 +++-
 .../deque.modifiers/erase_iter.invalidation.pass.cpp   |  4 +++-
 .../deque/deque.modifiers/erase_iter.pass.cpp          |  4 +++-
 .../erase_iter_iter.invalidation.pass.cpp              |  4 +++-
 .../deque/deque.modifiers/erase_iter_iter.pass.cpp     |  4 +++-
 .../insert_iter_initializer_list.pass.cpp              |  4 +++-
 .../deque/deque.modifiers/insert_iter_iter.pass.cpp    |  4 +++-
 .../deque/deque.modifiers/insert_rvalue.pass.cpp       |  4 +++-
 .../deque/deque.modifiers/insert_size_value.pass.cpp   |  4 +++-
 .../deque/deque.modifiers/insert_value.pass.cpp        |  4 +++-
 .../deque.modifiers/pop_back.invalidation.pass.cpp     |  4 +++-
 .../sequences/deque/deque.modifiers/pop_back.pass.cpp  |  4 +++-
 .../deque.modifiers/pop_front.invalidation.pass.cpp    |  4 +++-
 .../sequences/deque/deque.modifiers/pop_front.pass.cpp |  4 +++-
 .../sequences/deque/deque.modifiers/push_back.pass.cpp |  4 +++-
 .../push_back_exception_safety.pass.cpp                |  4 +++-
 .../deque/deque.modifiers/push_back_rvalue.pass.cpp    |  4 +++-
 .../deque/deque.modifiers/push_front.pass.cpp          |  4 +++-
 .../push_front_exception_safety.pass.cpp               |  4 +++-
 .../deque/deque.modifiers/push_front_rvalue.pass.cpp   |  4 +++-
 .../sequences/deque/deque.special/copy.pass.cpp        |  4 +++-
 .../deque/deque.special/copy_backward.pass.cpp         |  4 +++-
 .../sequences/deque/deque.special/move.pass.cpp        |  4 +++-
 .../deque/deque.special/move_backward.pass.cpp         |  4 +++-
 .../sequences/deque/deque.special/swap.pass.cpp        |  4 +++-
 .../deque/deque.special/swap_noexcept.pass.cpp         |  4 +++-
 test/std/containers/sequences/deque/iterators.pass.cpp |  4 +++-
 test/std/containers/sequences/deque/types.pass.cpp     |  4 +++-
 .../sequences/forwardlist/allocator_mismatch.fail.cpp  |  4 +++-
 .../containers/sequences/forwardlist/empty.fail.cpp    |  4 +++-
 .../containers/sequences/forwardlist/empty.pass.cpp    |  4 +++-
 .../forwardlist/forwardlist.access/front.pass.cpp      |  4 +++-
 .../forwardlist/forwardlist.cons/alloc.fail.cpp        |  4 +++-
 .../forwardlist/forwardlist.cons/alloc.pass.cpp        |  4 +++-
 .../forwardlist/forwardlist.cons/assign_copy.pass.cpp  |  4 +++-
 .../forwardlist/forwardlist.cons/assign_init.pass.cpp  |  4 +++-
 .../forwardlist/forwardlist.cons/assign_move.pass.cpp  |  4 +++-
 .../forwardlist.cons/assign_op_init.pass.cpp           |  4 +++-
 .../forwardlist/forwardlist.cons/assign_range.pass.cpp |  4 +++-
 .../forwardlist.cons/assign_size_value.pass.cpp        |  4 +++-
 .../forwardlist/forwardlist.cons/copy.pass.cpp         |  4 +++-
 .../forwardlist/forwardlist.cons/copy_alloc.pass.cpp   |  4 +++-
 .../forwardlist/forwardlist.cons/deduct.fail.cpp       |  4 +++-
 .../forwardlist/forwardlist.cons/deduct.pass.cpp       |  4 +++-
 .../forwardlist/forwardlist.cons/default.pass.cpp      |  4 +++-
 .../forwardlist.cons/default_noexcept.pass.cpp         |  4 +++-
 .../forwardlist.cons/default_recursive.pass.cpp        |  4 +++-
 .../forwardlist.cons/dtor_noexcept.pass.cpp            |  4 +++-
 .../forwardlist/forwardlist.cons/init.pass.cpp         |  4 +++-
 .../forwardlist/forwardlist.cons/init_alloc.pass.cpp   |  4 +++-
 .../forwardlist/forwardlist.cons/move.pass.cpp         |  4 +++-
 .../forwardlist/forwardlist.cons/move_alloc.pass.cpp   |  4 +++-
 .../forwardlist.cons/move_assign_noexcept.pass.cpp     |  4 +++-
 .../forwardlist.cons/move_noexcept.pass.cpp            |  4 +++-
 .../forwardlist/forwardlist.cons/range.pass.cpp        |  4 +++-
 .../forwardlist/forwardlist.cons/range_alloc.pass.cpp  |  4 +++-
 .../forwardlist/forwardlist.cons/size.pass.cpp         |  4 +++-
 .../forwardlist/forwardlist.cons/size_value.pass.cpp   |  4 +++-
 .../forwardlist.cons/size_value_alloc.pass.cpp         |  4 +++-
 .../forwardlist/forwardlist.erasure/erase.pass.cpp     |  4 +++-
 .../forwardlist/forwardlist.erasure/erase_if.pass.cpp  |  4 +++-
 .../forwardlist/forwardlist.iter/before_begin.pass.cpp |  4 +++-
 .../forwardlist/forwardlist.iter/iterators.pass.cpp    |  4 +++-
 .../forwardlist/forwardlist.modifiers/clear.pass.cpp   |  4 +++-
 .../forwardlist.modifiers/emplace_after.pass.cpp       |  4 +++-
 .../forwardlist.modifiers/emplace_front.pass.cpp       |  4 +++-
 .../forwardlist.modifiers/erase_after_many.pass.cpp    |  4 +++-
 .../forwardlist.modifiers/erase_after_one.pass.cpp     |  4 +++-
 .../forwardlist.modifiers/insert_after_const.pass.cpp  |  4 +++-
 .../forwardlist.modifiers/insert_after_init.pass.cpp   |  4 +++-
 .../forwardlist.modifiers/insert_after_range.pass.cpp  |  4 +++-
 .../forwardlist.modifiers/insert_after_rv.pass.cpp     |  4 +++-
 .../insert_after_size_value.pass.cpp                   |  4 +++-
 .../forwardlist.modifiers/pop_front.pass.cpp           |  4 +++-
 .../forwardlist.modifiers/push_front_const.pass.cpp    |  4 +++-
 .../push_front_exception_safety.pass.cpp               |  4 +++-
 .../forwardlist.modifiers/push_front_rv.pass.cpp       |  4 +++-
 .../forwardlist.modifiers/resize_size.pass.cpp         |  4 +++-
 .../forwardlist.modifiers/resize_size_value.pass.cpp   |  4 +++-
 .../forwardlist/forwardlist.ops/merge.pass.cpp         |  4 +++-
 .../forwardlist/forwardlist.ops/merge_pred.pass.cpp    |  4 +++-
 .../forwardlist/forwardlist.ops/remove.pass.cpp        |  4 +++-
 .../forwardlist/forwardlist.ops/remove_if.pass.cpp     |  4 +++-
 .../forwardlist/forwardlist.ops/reverse.pass.cpp       |  4 +++-
 .../forwardlist/forwardlist.ops/sort.pass.cpp          |  4 +++-
 .../forwardlist/forwardlist.ops/sort_pred.pass.cpp     |  4 +++-
 .../forwardlist.ops/splice_after_flist.pass.cpp        |  4 +++-
 .../forwardlist.ops/splice_after_one.pass.cpp          |  4 +++-
 .../forwardlist.ops/splice_after_range.pass.cpp        |  4 +++-
 .../forwardlist/forwardlist.ops/unique.pass.cpp        |  4 +++-
 .../forwardlist/forwardlist.ops/unique_pred.pass.cpp   |  4 +++-
 .../forwardlist/forwardlist.spec/equal.pass.cpp        |  4 +++-
 .../forwardlist/forwardlist.spec/member_swap.pass.cpp  |  4 +++-
 .../forwardlist.spec/non_member_swap.pass.cpp          |  4 +++-
 .../forwardlist/forwardlist.spec/relational.pass.cpp   |  4 +++-
 .../forwardlist.spec/swap_noexcept.pass.cpp            |  4 +++-
 .../sequences/forwardlist/incomplete.pass.cpp          |  4 +++-
 .../containers/sequences/forwardlist/max_size.pass.cpp |  4 +++-
 .../containers/sequences/forwardlist/types.pass.cpp    |  4 +++-
 .../sequences/list/allocator_mismatch.fail.cpp         |  4 +++-
 .../containers/sequences/list/incomplete_type.pass.cpp |  4 +++-
 test/std/containers/sequences/list/iterators.pass.cpp  |  4 +++-
 .../sequences/list/list.capacity/empty.fail.cpp        |  4 +++-
 .../sequences/list/list.capacity/empty.pass.cpp        |  4 +++-
 .../sequences/list/list.capacity/max_size.pass.cpp     |  4 +++-
 .../sequences/list/list.capacity/resize_size.pass.cpp  |  4 +++-
 .../list/list.capacity/resize_size_value.pass.cpp      |  4 +++-
 .../sequences/list/list.capacity/size.pass.cpp         |  4 +++-
 .../sequences/list/list.cons/assign_copy.pass.cpp      |  4 +++-
 .../list/list.cons/assign_initializer_list.pass.cpp    |  4 +++-
 .../sequences/list/list.cons/assign_move.pass.cpp      |  4 +++-
 .../containers/sequences/list/list.cons/copy.pass.cpp  |  4 +++-
 .../sequences/list/list.cons/copy_alloc.pass.cpp       |  4 +++-
 .../sequences/list/list.cons/deduct.fail.cpp           |  4 +++-
 .../sequences/list/list.cons/deduct.pass.cpp           |  4 +++-
 .../sequences/list/list.cons/default.pass.cpp          |  4 +++-
 .../sequences/list/list.cons/default_noexcept.pass.cpp |  4 +++-
 .../list/list.cons/default_stack_alloc.pass.cpp        |  4 +++-
 .../sequences/list/list.cons/dtor_noexcept.pass.cpp    |  4 +++-
 .../sequences/list/list.cons/initializer_list.pass.cpp |  4 +++-
 .../list/list.cons/initializer_list_alloc.pass.cpp     |  4 +++-
 .../sequences/list/list.cons/input_iterator.pass.cpp   |  4 +++-
 .../containers/sequences/list/list.cons/move.pass.cpp  |  4 +++-
 .../sequences/list/list.cons/move_alloc.pass.cpp       |  4 +++-
 .../list/list.cons/move_assign_noexcept.pass.cpp       |  4 +++-
 .../sequences/list/list.cons/move_noexcept.pass.cpp    |  4 +++-
 .../list/list.cons/op_equal_initializer_list.pass.cpp  |  4 +++-
 .../sequences/list/list.cons/size_type.pass.cpp        |  4 +++-
 .../sequences/list/list.cons/size_value_alloc.pass.cpp |  4 +++-
 .../sequences/list/list.erasure/erase.pass.cpp         |  4 +++-
 .../sequences/list/list.erasure/erase_if.pass.cpp      |  4 +++-
 .../sequences/list/list.modifiers/clear.pass.cpp       |  4 +++-
 .../sequences/list/list.modifiers/emplace.pass.cpp     |  4 +++-
 .../list/list.modifiers/emplace_back.pass.cpp          |  4 +++-
 .../list/list.modifiers/emplace_front.pass.cpp         |  4 +++-
 .../sequences/list/list.modifiers/erase_iter.pass.cpp  |  4 +++-
 .../list/list.modifiers/erase_iter_iter.pass.cpp       |  4 +++-
 .../insert_iter_initializer_list.pass.cpp              |  4 +++-
 .../list/list.modifiers/insert_iter_iter_iter.pass.cpp |  4 +++-
 .../list/list.modifiers/insert_iter_rvalue.pass.cpp    |  4 +++-
 .../list.modifiers/insert_iter_size_value.pass.cpp     |  4 +++-
 .../list/list.modifiers/insert_iter_value.pass.cpp     |  4 +++-
 .../sequences/list/list.modifiers/pop_back.pass.cpp    |  4 +++-
 .../sequences/list/list.modifiers/pop_front.pass.cpp   |  4 +++-
 .../sequences/list/list.modifiers/push_back.pass.cpp   |  4 +++-
 .../list.modifiers/push_back_exception_safety.pass.cpp |  4 +++-
 .../list/list.modifiers/push_back_rvalue.pass.cpp      |  4 +++-
 .../sequences/list/list.modifiers/push_front.pass.cpp  |  4 +++-
 .../push_front_exception_safety.pass.cpp               |  4 +++-
 .../list/list.modifiers/push_front_rvalue.pass.cpp     |  4 +++-
 .../containers/sequences/list/list.ops/merge.pass.cpp  |  4 +++-
 .../sequences/list/list.ops/merge_comp.pass.cpp        |  4 +++-
 .../containers/sequences/list/list.ops/remove.pass.cpp |  4 +++-
 .../sequences/list/list.ops/remove_if.pass.cpp         |  4 +++-
 .../sequences/list/list.ops/reverse.pass.cpp           |  4 +++-
 .../containers/sequences/list/list.ops/sort.pass.cpp   |  4 +++-
 .../sequences/list/list.ops/sort_comp.pass.cpp         |  4 +++-
 .../sequences/list/list.ops/splice_pos_list.pass.cpp   |  4 +++-
 .../list/list.ops/splice_pos_list_iter.pass.cpp        |  4 +++-
 .../list/list.ops/splice_pos_list_iter_iter.pass.cpp   |  4 +++-
 .../containers/sequences/list/list.ops/unique.pass.cpp |  4 +++-
 .../sequences/list/list.ops/unique_pred.pass.cpp       |  4 +++-
 .../sequences/list/list.special/swap.pass.cpp          |  4 +++-
 .../sequences/list/list.special/swap_noexcept.pass.cpp |  4 +++-
 test/std/containers/sequences/list/types.pass.cpp      |  4 +++-
 test/std/containers/sequences/nothing_to_do.pass.cpp   |  4 +++-
 .../sequences/vector.bool/assign_copy.pass.cpp         |  4 +++-
 .../vector.bool/assign_initializer_list.pass.cpp       |  4 +++-
 .../sequences/vector.bool/assign_move.pass.cpp         |  4 +++-
 .../containers/sequences/vector.bool/capacity.pass.cpp |  4 +++-
 .../sequences/vector.bool/construct_default.pass.cpp   |  4 +++-
 .../sequences/vector.bool/construct_iter_iter.pass.cpp |  4 +++-
 .../vector.bool/construct_iter_iter_alloc.pass.cpp     |  4 +++-
 .../sequences/vector.bool/construct_size.pass.cpp      |  4 +++-
 .../vector.bool/construct_size_value.pass.cpp          |  4 +++-
 .../vector.bool/construct_size_value_alloc.pass.cpp    |  4 +++-
 .../std/containers/sequences/vector.bool/copy.pass.cpp |  4 +++-
 .../sequences/vector.bool/copy_alloc.pass.cpp          |  4 +++-
 .../sequences/vector.bool/default_noexcept.pass.cpp    |  4 +++-
 .../sequences/vector.bool/dtor_noexcept.pass.cpp       |  4 +++-
 .../containers/sequences/vector.bool/emplace.pass.cpp  |  4 +++-
 .../sequences/vector.bool/emplace_back.pass.cpp        |  4 +++-
 .../containers/sequences/vector.bool/empty.fail.cpp    |  4 +++-
 .../containers/sequences/vector.bool/empty.pass.cpp    |  4 +++-
 .../sequences/vector.bool/enabled_hash.pass.cpp        |  4 +++-
 .../sequences/vector.bool/erase_iter.pass.cpp          |  4 +++-
 .../sequences/vector.bool/erase_iter_iter.pass.cpp     |  4 +++-
 .../std/containers/sequences/vector.bool/find.pass.cpp |  4 +++-
 .../sequences/vector.bool/initializer_list.pass.cpp    |  4 +++-
 .../vector.bool/initializer_list_alloc.pass.cpp        |  4 +++-
 .../vector.bool/insert_iter_initializer_list.pass.cpp  |  4 +++-
 .../vector.bool/insert_iter_iter_iter.pass.cpp         |  4 +++-
 .../vector.bool/insert_iter_size_value.pass.cpp        |  4 +++-
 .../sequences/vector.bool/insert_iter_value.pass.cpp   |  4 +++-
 .../sequences/vector.bool/iterators.pass.cpp           |  4 +++-
 .../std/containers/sequences/vector.bool/move.pass.cpp |  4 +++-
 .../sequences/vector.bool/move_alloc.pass.cpp          |  4 +++-
 .../vector.bool/move_assign_noexcept.pass.cpp          |  4 +++-
 .../sequences/vector.bool/move_noexcept.pass.cpp       |  4 +++-
 .../vector.bool/op_equal_initializer_list.pass.cpp     |  4 +++-
 .../sequences/vector.bool/push_back.pass.cpp           |  4 +++-
 .../sequences/vector.bool/reference.swap.pass.cpp      |  4 +++-
 .../containers/sequences/vector.bool/reserve.pass.cpp  |  4 +++-
 .../sequences/vector.bool/resize_size.pass.cpp         |  4 +++-
 .../sequences/vector.bool/resize_size_value.pass.cpp   |  4 +++-
 .../sequences/vector.bool/shrink_to_fit.pass.cpp       |  4 +++-
 .../std/containers/sequences/vector.bool/size.pass.cpp |  4 +++-
 .../std/containers/sequences/vector.bool/swap.pass.cpp |  4 +++-
 .../sequences/vector.bool/swap_noexcept.pass.cpp       |  4 +++-
 .../containers/sequences/vector.bool/types.pass.cpp    |  4 +++-
 .../sequences/vector.bool/vector_bool.pass.cpp         |  4 +++-
 .../sequences/vector/allocator_mismatch.fail.cpp       |  4 +++-
 .../containers/sequences/vector/contiguous.pass.cpp    |  4 +++-
 .../std/containers/sequences/vector/iterators.pass.cpp |  4 +++-
 test/std/containers/sequences/vector/types.pass.cpp    |  4 +++-
 .../sequences/vector/vector.capacity/capacity.pass.cpp |  4 +++-
 .../sequences/vector/vector.capacity/empty.fail.cpp    |  4 +++-
 .../sequences/vector/vector.capacity/empty.pass.cpp    |  4 +++-
 .../sequences/vector/vector.capacity/max_size.pass.cpp |  4 +++-
 .../sequences/vector/vector.capacity/reserve.pass.cpp  |  4 +++-
 .../vector/vector.capacity/resize_size.pass.cpp        |  4 +++-
 .../vector/vector.capacity/resize_size_value.pass.cpp  |  4 +++-
 .../vector/vector.capacity/shrink_to_fit.pass.cpp      |  4 +++-
 .../sequences/vector/vector.capacity/size.pass.cpp     |  4 +++-
 .../sequences/vector/vector.capacity/swap.pass.cpp     |  4 +++-
 .../sequences/vector/vector.cons/assign_copy.pass.cpp  |  4 +++-
 .../vector.cons/assign_initializer_list.pass.cpp       |  4 +++-
 .../vector/vector.cons/assign_iter_iter.pass.cpp       |  4 +++-
 .../sequences/vector/vector.cons/assign_move.pass.cpp  |  4 +++-
 .../vector/vector.cons/assign_size_value.pass.cpp      |  4 +++-
 .../vector/vector.cons/construct_default.pass.cpp      |  4 +++-
 .../vector/vector.cons/construct_iter_iter.pass.cpp    |  4 +++-
 .../vector.cons/construct_iter_iter_alloc.pass.cpp     |  4 +++-
 .../vector/vector.cons/construct_size.pass.cpp         |  4 +++-
 .../vector/vector.cons/construct_size_value.pass.cpp   |  4 +++-
 .../vector.cons/construct_size_value_alloc.pass.cpp    |  4 +++-
 .../sequences/vector/vector.cons/copy.pass.cpp         |  4 +++-
 .../sequences/vector/vector.cons/copy_alloc.pass.cpp   |  4 +++-
 .../sequences/vector/vector.cons/deduct.fail.cpp       |  4 +++-
 .../sequences/vector/vector.cons/deduct.pass.cpp       |  4 +++-
 .../vector/vector.cons/default.recursive.pass.cpp      |  4 +++-
 .../vector/vector.cons/default_noexcept.pass.cpp       |  4 +++-
 .../vector/vector.cons/dtor_noexcept.pass.cpp          |  4 +++-
 .../vector/vector.cons/initializer_list.pass.cpp       |  4 +++-
 .../vector/vector.cons/initializer_list_alloc.pass.cpp |  4 +++-
 .../sequences/vector/vector.cons/move.pass.cpp         |  4 +++-
 .../sequences/vector/vector.cons/move_alloc.pass.cpp   |  4 +++-
 .../vector/vector.cons/move_assign_noexcept.pass.cpp   |  4 +++-
 .../vector/vector.cons/move_noexcept.pass.cpp          |  4 +++-
 .../vector.cons/op_equal_initializer_list.pass.cpp     |  4 +++-
 .../sequences/vector/vector.data/data.pass.cpp         |  4 +++-
 .../sequences/vector/vector.data/data_const.pass.cpp   |  4 +++-
 .../sequences/vector/vector.erasure/erase.pass.cpp     |  4 +++-
 .../sequences/vector/vector.erasure/erase_if.pass.cpp  |  4 +++-
 .../sequences/vector/vector.modifiers/clear.pass.cpp   |  4 +++-
 .../sequences/vector/vector.modifiers/emplace.pass.cpp |  4 +++-
 .../vector/vector.modifiers/emplace_back.pass.cpp      |  4 +++-
 .../vector/vector.modifiers/emplace_extra.pass.cpp     |  4 +++-
 .../vector/vector.modifiers/erase_iter.pass.cpp        |  4 +++-
 .../vector/vector.modifiers/erase_iter_iter.pass.cpp   |  4 +++-
 .../insert_iter_initializer_list.pass.cpp              |  4 +++-
 .../vector.modifiers/insert_iter_iter_iter.pass.cpp    |  4 +++-
 .../vector.modifiers/insert_iter_rvalue.pass.cpp       |  4 +++-
 .../vector.modifiers/insert_iter_size_value.pass.cpp   |  4 +++-
 .../vector/vector.modifiers/insert_iter_value.pass.cpp |  4 +++-
 .../vector/vector.modifiers/pop_back.pass.cpp          |  4 +++-
 .../vector/vector.modifiers/push_back.pass.cpp         |  4 +++-
 .../push_back_exception_safety.pass.cpp                |  4 +++-
 .../vector/vector.modifiers/push_back_rvalue.pass.cpp  |  4 +++-
 .../sequences/vector/vector.special/swap.pass.cpp      |  4 +++-
 .../vector/vector.special/swap_noexcept.pass.cpp       |  4 +++-
 .../containers/unord/iterator_difference_type.pass.cpp |  4 +++-
 .../unord/unord.map/allocator_mismatch.fail.cpp        |  4 +++-
 test/std/containers/unord/unord.map/bucket.pass.cpp    |  4 +++-
 .../containers/unord/unord.map/bucket_count.pass.cpp   |  4 +++-
 .../containers/unord/unord.map/bucket_size.pass.cpp    |  4 +++-
 test/std/containers/unord/unord.map/compare.pass.cpp   |  4 +++-
 test/std/containers/unord/unord.map/count.pass.cpp     |  4 +++-
 test/std/containers/unord/unord.map/empty.fail.cpp     |  4 +++-
 test/std/containers/unord/unord.map/empty.pass.cpp     |  4 +++-
 test/std/containers/unord/unord.map/eq.pass.cpp        |  4 +++-
 .../unord/unord.map/equal_range_const.pass.cpp         |  4 +++-
 .../unord/unord.map/equal_range_non_const.pass.cpp     |  4 +++-
 test/std/containers/unord/unord.map/erase_if.pass.cpp  |  4 +++-
 .../std/containers/unord/unord.map/find_const.pass.cpp |  4 +++-
 .../containers/unord/unord.map/find_non_const.pass.cpp |  4 +++-
 .../unord/unord.map/incomplete_type.pass.cpp           |  4 +++-
 test/std/containers/unord/unord.map/iterators.pass.cpp |  4 +++-
 .../containers/unord/unord.map/load_factor.pass.cpp    |  4 +++-
 .../unord/unord.map/local_iterators.pass.cpp           |  4 +++-
 .../unord/unord.map/max_bucket_count.pass.cpp          |  4 +++-
 .../unord/unord.map/max_load_factor.pass.cpp           |  4 +++-
 test/std/containers/unord/unord.map/max_size.pass.cpp  |  4 +++-
 test/std/containers/unord/unord.map/rehash.pass.cpp    |  4 +++-
 test/std/containers/unord/unord.map/reserve.pass.cpp   |  4 +++-
 test/std/containers/unord/unord.map/size.pass.cpp      |  4 +++-
 .../containers/unord/unord.map/swap_member.pass.cpp    |  4 +++-
 test/std/containers/unord/unord.map/types.pass.cpp     |  4 +++-
 .../unord/unord.map/unord.map.cnstr/allocator.pass.cpp |  4 +++-
 .../unord.map/unord.map.cnstr/assign_copy.pass.cpp     |  4 +++-
 .../unord.map/unord.map.cnstr/assign_init.pass.cpp     |  4 +++-
 .../unord.map/unord.map.cnstr/assign_move.pass.cpp     |  4 +++-
 .../compare_copy_constructible.fail.cpp                |  4 +++-
 .../unord/unord.map/unord.map.cnstr/copy.pass.cpp      |  4 +++-
 .../unord.map/unord.map.cnstr/copy_alloc.pass.cpp      |  4 +++-
 .../unord/unord.map/unord.map.cnstr/default.pass.cpp   |  4 +++-
 .../unord.map.cnstr/default_noexcept.pass.cpp          |  4 +++-
 .../unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp   |  4 +++-
 .../unord.map.cnstr/hash_copy_constructible.fail.cpp   |  4 +++-
 .../unord/unord.map/unord.map.cnstr/init.pass.cpp      |  4 +++-
 .../unord/unord.map/unord.map.cnstr/init_size.pass.cpp |  4 +++-
 .../unord.map/unord.map.cnstr/init_size_hash.pass.cpp  |  4 +++-
 .../unord.map.cnstr/init_size_hash_equal.pass.cpp      |  4 +++-
 .../init_size_hash_equal_allocator.pass.cpp            |  4 +++-
 .../unord/unord.map/unord.map.cnstr/move.pass.cpp      |  4 +++-
 .../unord.map/unord.map.cnstr/move_alloc.pass.cpp      |  4 +++-
 .../unord.map.cnstr/move_assign_noexcept.pass.cpp      |  4 +++-
 .../unord.map/unord.map.cnstr/move_noexcept.pass.cpp   |  4 +++-
 .../unord/unord.map/unord.map.cnstr/range.pass.cpp     |  4 +++-
 .../unord.map/unord.map.cnstr/range_size.pass.cpp      |  4 +++-
 .../unord.map/unord.map.cnstr/range_size_hash.pass.cpp |  4 +++-
 .../unord.map.cnstr/range_size_hash_equal.pass.cpp     |  4 +++-
 .../range_size_hash_equal_allocator.pass.cpp           |  4 +++-
 .../unord/unord.map/unord.map.cnstr/size.fail.cpp      |  4 +++-
 .../unord/unord.map/unord.map.cnstr/size.pass.cpp      |  4 +++-
 .../unord/unord.map/unord.map.cnstr/size_hash.pass.cpp |  4 +++-
 .../unord.map/unord.map.cnstr/size_hash_equal.pass.cpp |  4 +++-
 .../unord.map.cnstr/size_hash_equal_allocator.pass.cpp |  4 +++-
 .../unord/unord.map/unord.map.elem/at.pass.cpp         |  4 +++-
 .../unord/unord.map/unord.map.elem/index.pass.cpp      |  4 +++-
 .../unord.map/unord.map.elem/index_tuple.pass.cpp      |  4 +++-
 .../unord/unord.map/unord.map.modifiers/clear.pass.cpp |  4 +++-
 .../unord.map/unord.map.modifiers/emplace.pass.cpp     |  4 +++-
 .../unord.map.modifiers/emplace_hint.pass.cpp          |  4 +++-
 .../unord.map.modifiers/erase_const_iter.pass.cpp      |  4 +++-
 .../unord.map.modifiers/erase_iter_db1.pass.cpp        |  6 ++++--
 .../unord.map.modifiers/erase_iter_db2.pass.cpp        |  6 ++++--
 .../unord.map.modifiers/erase_iter_iter_db1.pass.cpp   |  6 ++++--
 .../unord.map.modifiers/erase_iter_iter_db2.pass.cpp   |  6 ++++--
 .../unord.map.modifiers/erase_iter_iter_db3.pass.cpp   |  6 ++++--
 .../unord.map.modifiers/erase_iter_iter_db4.pass.cpp   |  6 ++++--
 .../unord.map/unord.map.modifiers/erase_key.pass.cpp   |  4 +++-
 .../unord.map/unord.map.modifiers/erase_range.pass.cpp |  4 +++-
 .../unord.map.modifiers/extract_iterator.pass.cpp      |  4 +++-
 .../unord.map/unord.map.modifiers/extract_key.pass.cpp |  4 +++-
 .../insert_and_emplace_allocator_requirements.pass.cpp |  4 +++-
 .../unord.map.modifiers/insert_const_lvalue.pass.cpp   |  4 +++-
 .../insert_hint_const_lvalue.pass.cpp                  |  4 +++-
 .../unord.map.modifiers/insert_hint_rvalue.pass.cpp    |  4 +++-
 .../unord.map/unord.map.modifiers/insert_init.pass.cpp |  4 +++-
 .../unord.map.modifiers/insert_node_type.pass.cpp      |  4 +++-
 .../unord.map.modifiers/insert_node_type_hint.pass.cpp |  4 +++-
 .../unord.map.modifiers/insert_or_assign.pass.cpp      |  4 +++-
 .../unord.map.modifiers/insert_range.pass.cpp          |  4 +++-
 .../unord.map.modifiers/insert_rvalue.pass.cpp         |  4 +++-
 .../unord/unord.map/unord.map.modifiers/merge.pass.cpp |  3 ++-
 .../unord.map/unord.map.modifiers/try.emplace.pass.cpp |  4 +++-
 .../unord/unord.map/unord.map.swap/db_swap_1.pass.cpp  |  4 +++-
 .../unord.map/unord.map.swap/swap_noexcept.pass.cpp    |  4 +++-
 .../unord.map/unord.map.swap/swap_non_member.pass.cpp  |  4 +++-
 .../unord/unord.multimap/allocator_mismatch.fail.cpp   |  4 +++-
 .../containers/unord/unord.multimap/bucket.pass.cpp    |  4 +++-
 .../unord/unord.multimap/bucket_count.pass.cpp         |  4 +++-
 .../unord/unord.multimap/bucket_size.pass.cpp          |  4 +++-
 .../std/containers/unord/unord.multimap/count.pass.cpp |  4 +++-
 .../unord/unord.multimap/db_iterators_7.pass.cpp       |  6 ++++--
 .../unord/unord.multimap/db_iterators_8.pass.cpp       |  6 ++++--
 .../unord/unord.multimap/db_local_iterators_7.pass.cpp |  6 ++++--
 .../unord/unord.multimap/db_local_iterators_8.pass.cpp |  6 ++++--
 .../std/containers/unord/unord.multimap/empty.fail.cpp |  4 +++-
 .../std/containers/unord/unord.multimap/empty.pass.cpp |  4 +++-
 test/std/containers/unord/unord.multimap/eq.pass.cpp   |  4 +++-
 .../unord/unord.multimap/equal_range_const.pass.cpp    |  4 +++-
 .../unord.multimap/equal_range_non_const.pass.cpp      |  4 +++-
 .../containers/unord/unord.multimap/erase_if.pass.cpp  |  4 +++-
 .../unord/unord.multimap/find_const.pass.cpp           |  4 +++-
 .../unord/unord.multimap/find_non_const.pass.cpp       |  4 +++-
 .../unord/unord.multimap/incomplete.pass.cpp           |  4 +++-
 .../containers/unord/unord.multimap/iterators.fail.cpp |  4 +++-
 .../containers/unord/unord.multimap/iterators.pass.cpp |  4 +++-
 .../unord/unord.multimap/load_factor.pass.cpp          |  4 +++-
 .../unord/unord.multimap/local_iterators.fail.cpp      |  4 +++-
 .../unord/unord.multimap/local_iterators.pass.cpp      |  4 +++-
 .../unord/unord.multimap/max_bucket_count.pass.cpp     |  4 +++-
 .../unord/unord.multimap/max_load_factor.pass.cpp      |  4 +++-
 .../containers/unord/unord.multimap/max_size.pass.cpp  |  4 +++-
 .../containers/unord/unord.multimap/rehash.pass.cpp    |  4 +++-
 .../containers/unord/unord.multimap/reserve.pass.cpp   |  4 +++-
 .../std/containers/unord/unord.multimap/scary.pass.cpp |  4 +++-
 test/std/containers/unord/unord.multimap/size.pass.cpp |  4 +++-
 .../unord/unord.multimap/swap_member.pass.cpp          |  4 +++-
 .../std/containers/unord/unord.multimap/types.pass.cpp |  4 +++-
 .../unord.multimap.cnstr/allocator.pass.cpp            |  4 +++-
 .../unord.multimap.cnstr/assign_copy.pass.cpp          |  4 +++-
 .../unord.multimap.cnstr/assign_init.pass.cpp          |  4 +++-
 .../unord.multimap.cnstr/assign_move.pass.cpp          |  4 +++-
 .../compare_copy_constructible.fail.cpp                |  4 +++-
 .../unord.multimap/unord.multimap.cnstr/copy.pass.cpp  |  4 +++-
 .../unord.multimap.cnstr/copy_alloc.pass.cpp           |  4 +++-
 .../unord.multimap.cnstr/default.pass.cpp              |  4 +++-
 .../unord.multimap.cnstr/default_noexcept.pass.cpp     |  4 +++-
 .../unord.multimap.cnstr/dtor_noexcept.pass.cpp        |  4 +++-
 .../hash_copy_constructible.fail.cpp                   |  4 +++-
 .../unord.multimap/unord.multimap.cnstr/init.pass.cpp  |  4 +++-
 .../unord.multimap.cnstr/init_size.pass.cpp            |  4 +++-
 .../unord.multimap.cnstr/init_size_hash.pass.cpp       |  4 +++-
 .../unord.multimap.cnstr/init_size_hash_equal.pass.cpp |  4 +++-
 .../init_size_hash_equal_allocator.pass.cpp            |  4 +++-
 .../unord.multimap/unord.multimap.cnstr/move.pass.cpp  |  4 +++-
 .../unord.multimap.cnstr/move_alloc.pass.cpp           |  4 +++-
 .../unord.multimap.cnstr/move_assign_noexcept.pass.cpp |  4 +++-
 .../unord.multimap.cnstr/move_noexcept.pass.cpp        |  4 +++-
 .../unord.multimap/unord.multimap.cnstr/range.pass.cpp |  4 +++-
 .../unord.multimap.cnstr/range_size.pass.cpp           |  4 +++-
 .../unord.multimap.cnstr/range_size_hash.pass.cpp      |  4 +++-
 .../range_size_hash_equal.pass.cpp                     |  4 +++-
 .../range_size_hash_equal_allocator.pass.cpp           |  4 +++-
 .../unord.multimap/unord.multimap.cnstr/size.fail.cpp  |  4 +++-
 .../unord.multimap/unord.multimap.cnstr/size.pass.cpp  |  4 +++-
 .../unord.multimap.cnstr/size_hash.pass.cpp            |  4 +++-
 .../unord.multimap.cnstr/size_hash_equal.pass.cpp      |  4 +++-
 .../size_hash_equal_allocator.pass.cpp                 |  4 +++-
 .../unord.multimap.modifiers/clear.pass.cpp            |  4 +++-
 .../unord.multimap.modifiers/emplace.pass.cpp          |  4 +++-
 .../unord.multimap.modifiers/emplace_hint.pass.cpp     |  4 +++-
 .../unord.multimap.modifiers/erase_const_iter.pass.cpp |  4 +++-
 .../unord.multimap.modifiers/erase_iter_db1.pass.cpp   |  6 ++++--
 .../unord.multimap.modifiers/erase_iter_db2.pass.cpp   |  6 ++++--
 .../erase_iter_iter_db1.pass.cpp                       |  6 ++++--
 .../erase_iter_iter_db2.pass.cpp                       |  6 ++++--
 .../erase_iter_iter_db3.pass.cpp                       |  6 ++++--
 .../erase_iter_iter_db4.pass.cpp                       |  6 ++++--
 .../unord.multimap.modifiers/erase_key.pass.cpp        |  4 +++-
 .../unord.multimap.modifiers/erase_range.pass.cpp      |  4 +++-
 .../unord.multimap.modifiers/extract_iterator.pass.cpp |  4 +++-
 .../unord.multimap.modifiers/extract_key.pass.cpp      |  4 +++-
 .../insert_allocator_requirements.pass.cpp             |  4 +++-
 .../insert_const_lvalue.pass.cpp                       |  4 +++-
 .../insert_hint_const_lvalue.pass.cpp                  |  4 +++-
 .../insert_hint_rvalue.pass.cpp                        |  4 +++-
 .../unord.multimap.modifiers/insert_init.pass.cpp      |  4 +++-
 .../unord.multimap.modifiers/insert_node_type.pass.cpp |  4 +++-
 .../insert_node_type_hint.pass.cpp                     |  4 +++-
 .../unord.multimap.modifiers/insert_range.pass.cpp     |  4 +++-
 .../unord.multimap.modifiers/insert_rvalue.pass.cpp    |  4 +++-
 .../unord.multimap.modifiers/merge.pass.cpp            |  3 ++-
 .../unord.multimap.swap/db_swap_1.pass.cpp             |  4 +++-
 .../unord.multimap.swap/swap_noexcept.pass.cpp         |  4 +++-
 .../unord.multimap.swap/swap_non_member.pass.cpp       |  4 +++-
 .../unord/unord.multiset/allocator_mismatch.fail.cpp   |  4 +++-
 .../containers/unord/unord.multiset/bucket.pass.cpp    |  4 +++-
 .../unord/unord.multiset/bucket_count.pass.cpp         |  4 +++-
 .../unord/unord.multiset/bucket_size.pass.cpp          |  4 +++-
 .../std/containers/unord/unord.multiset/clear.pass.cpp |  4 +++-
 .../std/containers/unord/unord.multiset/count.pass.cpp |  4 +++-
 .../unord/unord.multiset/db_iterators_7.pass.cpp       |  6 ++++--
 .../unord/unord.multiset/db_iterators_8.pass.cpp       |  6 ++++--
 .../unord/unord.multiset/db_local_iterators_7.pass.cpp |  6 ++++--
 .../unord/unord.multiset/db_local_iterators_8.pass.cpp |  6 ++++--
 .../containers/unord/unord.multiset/emplace.pass.cpp   |  4 +++-
 .../unord/unord.multiset/emplace_hint.pass.cpp         |  4 +++-
 .../std/containers/unord/unord.multiset/empty.fail.cpp |  4 +++-
 .../std/containers/unord/unord.multiset/empty.pass.cpp |  4 +++-
 test/std/containers/unord/unord.multiset/eq.pass.cpp   |  4 +++-
 .../unord/unord.multiset/equal_range_const.pass.cpp    |  4 +++-
 .../unord.multiset/equal_range_non_const.pass.cpp      |  4 +++-
 .../unord/unord.multiset/erase_const_iter.pass.cpp     |  4 +++-
 .../containers/unord/unord.multiset/erase_if.pass.cpp  |  4 +++-
 .../unord/unord.multiset/erase_iter_db1.pass.cpp       |  6 ++++--
 .../unord/unord.multiset/erase_iter_db2.pass.cpp       |  6 ++++--
 .../unord/unord.multiset/erase_iter_iter_db1.pass.cpp  |  6 ++++--
 .../unord/unord.multiset/erase_iter_iter_db2.pass.cpp  |  6 ++++--
 .../unord/unord.multiset/erase_iter_iter_db3.pass.cpp  |  6 ++++--
 .../unord/unord.multiset/erase_iter_iter_db4.pass.cpp  |  6 ++++--
 .../containers/unord/unord.multiset/erase_key.pass.cpp |  4 +++-
 .../unord/unord.multiset/erase_range.pass.cpp          |  4 +++-
 .../unord/unord.multiset/extract_iterator.pass.cpp     |  4 +++-
 .../unord/unord.multiset/extract_key.pass.cpp          |  4 +++-
 .../unord/unord.multiset/find_const.pass.cpp           |  4 +++-
 .../unord/unord.multiset/find_non_const.pass.cpp       |  4 +++-
 .../unord/unord.multiset/incomplete.pass.cpp           |  4 +++-
 .../unord/unord.multiset/insert_const_lvalue.pass.cpp  |  4 +++-
 .../insert_emplace_allocator_requirements.pass.cpp     |  4 +++-
 .../unord.multiset/insert_hint_const_lvalue.pass.cpp   |  4 +++-
 .../unord/unord.multiset/insert_hint_rvalue.pass.cpp   |  4 +++-
 .../unord/unord.multiset/insert_init.pass.cpp          |  4 +++-
 .../unord/unord.multiset/insert_node_type.pass.cpp     |  4 +++-
 .../unord.multiset/insert_node_type_hint.pass.cpp      |  4 +++-
 .../unord/unord.multiset/insert_range.pass.cpp         |  4 +++-
 .../unord/unord.multiset/insert_rvalue.pass.cpp        |  4 +++-
 .../containers/unord/unord.multiset/iterators.fail.cpp |  4 +++-
 .../containers/unord/unord.multiset/iterators.pass.cpp |  4 +++-
 .../unord/unord.multiset/load_factor.pass.cpp          |  4 +++-
 .../unord/unord.multiset/local_iterators.fail.cpp      |  4 +++-
 .../unord/unord.multiset/local_iterators.pass.cpp      |  4 +++-
 .../unord/unord.multiset/max_bucket_count.pass.cpp     |  4 +++-
 .../unord/unord.multiset/max_load_factor.pass.cpp      |  4 +++-
 .../containers/unord/unord.multiset/max_size.pass.cpp  |  4 +++-
 .../std/containers/unord/unord.multiset/merge.pass.cpp |  3 ++-
 .../containers/unord/unord.multiset/rehash.pass.cpp    |  4 +++-
 .../containers/unord/unord.multiset/reserve.pass.cpp   |  4 +++-
 .../std/containers/unord/unord.multiset/scary.pass.cpp |  4 +++-
 test/std/containers/unord/unord.multiset/size.pass.cpp |  4 +++-
 .../unord/unord.multiset/swap_member.pass.cpp          |  4 +++-
 .../std/containers/unord/unord.multiset/types.pass.cpp |  4 +++-
 .../unord.multiset.cnstr/allocator.pass.cpp            |  4 +++-
 .../unord.multiset.cnstr/assign_copy.pass.cpp          |  4 +++-
 .../unord.multiset.cnstr/assign_init.pass.cpp          |  4 +++-
 .../unord.multiset.cnstr/assign_move.pass.cpp          |  4 +++-
 .../compare_copy_constructible.fail.cpp                |  4 +++-
 .../unord.multiset/unord.multiset.cnstr/copy.pass.cpp  |  4 +++-
 .../unord.multiset.cnstr/copy_alloc.pass.cpp           |  4 +++-
 .../unord.multiset.cnstr/default.pass.cpp              |  4 +++-
 .../unord.multiset.cnstr/default_noexcept.pass.cpp     |  4 +++-
 .../unord.multiset.cnstr/dtor_noexcept.pass.cpp        |  4 +++-
 .../hash_copy_constructible.fail.cpp                   |  4 +++-
 .../unord.multiset/unord.multiset.cnstr/init.pass.cpp  |  4 +++-
 .../unord.multiset.cnstr/init_size.pass.cpp            |  4 +++-
 .../unord.multiset.cnstr/init_size_hash.pass.cpp       |  4 +++-
 .../unord.multiset.cnstr/init_size_hash_equal.pass.cpp |  4 +++-
 .../init_size_hash_equal_allocator.pass.cpp            |  4 +++-
 .../unord.multiset/unord.multiset.cnstr/move.pass.cpp  |  4 +++-
 .../unord.multiset.cnstr/move_alloc.pass.cpp           |  4 +++-
 .../unord.multiset.cnstr/move_assign_noexcept.pass.cpp |  4 +++-
 .../unord.multiset.cnstr/move_noexcept.pass.cpp        |  4 +++-
 .../unord.multiset/unord.multiset.cnstr/range.pass.cpp |  4 +++-
 .../unord.multiset.cnstr/range_size.pass.cpp           |  4 +++-
 .../unord.multiset.cnstr/range_size_hash.pass.cpp      |  4 +++-
 .../range_size_hash_equal.pass.cpp                     |  4 +++-
 .../range_size_hash_equal_allocator.pass.cpp           |  4 +++-
 .../unord.multiset/unord.multiset.cnstr/size.fail.cpp  |  4 +++-
 .../unord.multiset/unord.multiset.cnstr/size.pass.cpp  |  4 +++-
 .../unord.multiset.cnstr/size_hash.pass.cpp            |  4 +++-
 .../unord.multiset.cnstr/size_hash_equal.pass.cpp      |  4 +++-
 .../size_hash_equal_allocator.pass.cpp                 |  4 +++-
 .../unord.multiset.swap/db_swap_1.pass.cpp             |  4 +++-
 .../unord.multiset.swap/swap_noexcept.pass.cpp         |  4 +++-
 .../unord.multiset.swap/swap_non_member.pass.cpp       |  4 +++-
 .../unord/unord.set/allocator_mismatch.fail.cpp        |  4 +++-
 test/std/containers/unord/unord.set/bucket.pass.cpp    |  4 +++-
 .../containers/unord/unord.set/bucket_count.pass.cpp   |  4 +++-
 .../containers/unord/unord.set/bucket_size.pass.cpp    |  4 +++-
 test/std/containers/unord/unord.set/clear.pass.cpp     |  4 +++-
 test/std/containers/unord/unord.set/count.pass.cpp     |  4 +++-
 .../containers/unord/unord.set/db_iterators_7.pass.cpp |  6 ++++--
 .../containers/unord/unord.set/db_iterators_8.pass.cpp |  6 ++++--
 .../unord/unord.set/db_local_iterators_7.pass.cpp      |  6 ++++--
 .../unord/unord.set/db_local_iterators_8.pass.cpp      |  6 ++++--
 test/std/containers/unord/unord.set/emplace.pass.cpp   |  4 +++-
 .../containers/unord/unord.set/emplace_hint.pass.cpp   |  4 +++-
 test/std/containers/unord/unord.set/empty.fail.cpp     |  4 +++-
 test/std/containers/unord/unord.set/empty.pass.cpp     |  4 +++-
 test/std/containers/unord/unord.set/eq.pass.cpp        |  4 +++-
 .../unord/unord.set/equal_range_const.pass.cpp         |  4 +++-
 .../unord/unord.set/equal_range_non_const.pass.cpp     |  4 +++-
 .../unord/unord.set/erase_const_iter.pass.cpp          |  4 +++-
 test/std/containers/unord/unord.set/erase_if.pass.cpp  |  4 +++-
 .../containers/unord/unord.set/erase_iter_db1.pass.cpp |  6 ++++--
 .../containers/unord/unord.set/erase_iter_db2.pass.cpp |  6 ++++--
 .../unord/unord.set/erase_iter_iter_db1.pass.cpp       |  6 ++++--
 .../unord/unord.set/erase_iter_iter_db2.pass.cpp       |  6 ++++--
 .../unord/unord.set/erase_iter_iter_db3.pass.cpp       |  6 ++++--
 .../unord/unord.set/erase_iter_iter_db4.pass.cpp       |  6 ++++--
 test/std/containers/unord/unord.set/erase_key.pass.cpp |  4 +++-
 .../containers/unord/unord.set/erase_range.pass.cpp    |  4 +++-
 .../unord/unord.set/extract_iterator.pass.cpp          |  4 +++-
 .../containers/unord/unord.set/extract_key.pass.cpp    |  4 +++-
 .../std/containers/unord/unord.set/find_const.pass.cpp |  4 +++-
 .../containers/unord/unord.set/find_non_const.pass.cpp |  4 +++-
 .../std/containers/unord/unord.set/incomplete.pass.cpp |  4 +++-
 .../insert_and_emplace_allocator_requirements.pass.cpp |  4 +++-
 .../unord/unord.set/insert_const_lvalue.pass.cpp       |  4 +++-
 .../unord/unord.set/insert_hint_const_lvalue.pass.cpp  |  4 +++-
 .../unord/unord.set/insert_hint_rvalue.pass.cpp        |  4 +++-
 .../containers/unord/unord.set/insert_init.pass.cpp    |  4 +++-
 .../unord/unord.set/insert_node_type.pass.cpp          |  4 +++-
 .../unord/unord.set/insert_node_type_hint.pass.cpp     |  4 +++-
 .../containers/unord/unord.set/insert_range.pass.cpp   |  4 +++-
 .../containers/unord/unord.set/insert_rvalue.pass.cpp  |  4 +++-
 test/std/containers/unord/unord.set/iterators.fail.cpp |  4 +++-
 test/std/containers/unord/unord.set/iterators.pass.cpp |  4 +++-
 .../containers/unord/unord.set/load_factor.pass.cpp    |  4 +++-
 .../unord/unord.set/local_iterators.fail.cpp           |  4 +++-
 .../unord/unord.set/local_iterators.pass.cpp           |  4 +++-
 .../unord/unord.set/max_bucket_count.pass.cpp          |  4 +++-
 .../unord/unord.set/max_load_factor.pass.cpp           |  4 +++-
 test/std/containers/unord/unord.set/max_size.pass.cpp  |  4 +++-
 test/std/containers/unord/unord.set/merge.pass.cpp     |  3 ++-
 test/std/containers/unord/unord.set/rehash.pass.cpp    |  4 +++-
 test/std/containers/unord/unord.set/reserve.pass.cpp   |  4 +++-
 test/std/containers/unord/unord.set/size.pass.cpp      |  4 +++-
 .../containers/unord/unord.set/swap_member.pass.cpp    |  4 +++-
 test/std/containers/unord/unord.set/types.pass.cpp     |  4 +++-
 .../unord/unord.set/unord.set.cnstr/allocator.pass.cpp |  4 +++-
 .../unord.set/unord.set.cnstr/assign_copy.pass.cpp     |  4 +++-
 .../unord.set/unord.set.cnstr/assign_init.pass.cpp     |  4 +++-
 .../unord.set/unord.set.cnstr/assign_move.pass.cpp     |  4 +++-
 .../compare_copy_constructible.fail.cpp                |  4 +++-
 .../unord/unord.set/unord.set.cnstr/copy.pass.cpp      |  4 +++-
 .../unord.set/unord.set.cnstr/copy_alloc.pass.cpp      |  4 +++-
 .../unord/unord.set/unord.set.cnstr/default.pass.cpp   |  4 +++-
 .../unord.set.cnstr/default_noexcept.pass.cpp          |  4 +++-
 .../unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp   |  4 +++-
 .../unord.set.cnstr/hash_copy_constructible.fail.cpp   |  4 +++-
 .../unord/unord.set/unord.set.cnstr/init.pass.cpp      |  4 +++-
 .../unord/unord.set/unord.set.cnstr/init_size.pass.cpp |  4 +++-
 .../unord.set/unord.set.cnstr/init_size_hash.pass.cpp  |  4 +++-
 .../unord.set.cnstr/init_size_hash_equal.pass.cpp      |  4 +++-
 .../init_size_hash_equal_allocator.pass.cpp            |  4 +++-
 .../unord/unord.set/unord.set.cnstr/move.pass.cpp      |  4 +++-
 .../unord.set/unord.set.cnstr/move_alloc.pass.cpp      |  4 +++-
 .../unord.set.cnstr/move_assign_noexcept.pass.cpp      |  4 +++-
 .../unord.set/unord.set.cnstr/move_noexcept.pass.cpp   |  4 +++-
 .../unord/unord.set/unord.set.cnstr/range.pass.cpp     |  4 +++-
 .../unord.set/unord.set.cnstr/range_size.pass.cpp      |  4 +++-
 .../unord.set/unord.set.cnstr/range_size_hash.pass.cpp |  4 +++-
 .../unord.set.cnstr/range_size_hash_equal.pass.cpp     |  4 +++-
 .../range_size_hash_equal_allocator.pass.cpp           |  4 +++-
 .../unord/unord.set/unord.set.cnstr/size.fail.cpp      |  4 +++-
 .../unord/unord.set/unord.set.cnstr/size.pass.cpp      |  4 +++-
 .../unord/unord.set/unord.set.cnstr/size_hash.pass.cpp |  4 +++-
 .../unord.set/unord.set.cnstr/size_hash_equal.pass.cpp |  4 +++-
 .../unord.set.cnstr/size_hash_equal_allocator.pass.cpp |  4 +++-
 .../unord/unord.set/unord.set.swap/db_swap_1.pass.cpp  |  4 +++-
 .../unord.set/unord.set.swap/swap_noexcept.pass.cpp    |  4 +++-
 .../unord.set/unord.set.swap/swap_non_member.pass.cpp  |  4 +++-
 test/std/containers/views/span.cons/array.fail.cpp     |  4 +++-
 test/std/containers/views/span.cons/array.pass.cpp     |  4 +++-
 test/std/containers/views/span.cons/assign.pass.cpp    |  4 +++-
 test/std/containers/views/span.cons/container.fail.cpp |  4 +++-
 test/std/containers/views/span.cons/container.pass.cpp |  4 +++-
 test/std/containers/views/span.cons/copy.pass.cpp      |  4 +++-
 test/std/containers/views/span.cons/deduct.pass.cpp    |  4 +++-
 test/std/containers/views/span.cons/default.fail.cpp   |  4 +++-
 test/std/containers/views/span.cons/default.pass.cpp   |  4 +++-
 test/std/containers/views/span.cons/ptr_len.fail.cpp   |  4 +++-
 test/std/containers/views/span.cons/ptr_len.pass.cpp   |  4 +++-
 test/std/containers/views/span.cons/ptr_ptr.fail.cpp   |  4 +++-
 test/std/containers/views/span.cons/ptr_ptr.pass.cpp   |  4 +++-
 test/std/containers/views/span.cons/span.fail.cpp      |  4 +++-
 test/std/containers/views/span.cons/span.pass.cpp      |  4 +++-
 test/std/containers/views/span.cons/stdarray.pass.cpp  |  4 +++-
 test/std/containers/views/span.elem/data.pass.cpp      |  4 +++-
 test/std/containers/views/span.elem/op_idx.pass.cpp    |  4 +++-
 .../std/containers/views/span.iterators/begin.pass.cpp |  4 +++-
 test/std/containers/views/span.iterators/end.pass.cpp  |  4 +++-
 .../containers/views/span.iterators/rbegin.pass.cpp    |  4 +++-
 test/std/containers/views/span.iterators/rend.pass.cpp |  4 +++-
 .../containers/views/span.objectrep/as_bytes.pass.cpp  |  4 +++-
 .../views/span.objectrep/as_writeable_bytes.fail.cpp   |  4 +++-
 .../views/span.objectrep/as_writeable_bytes.pass.cpp   |  4 +++-
 test/std/containers/views/span.obs/empty.pass.cpp      |  4 +++-
 test/std/containers/views/span.obs/size.pass.cpp       |  4 +++-
 test/std/containers/views/span.obs/size_bytes.pass.cpp |  4 +++-
 test/std/containers/views/span.sub/first.pass.cpp      |  4 +++-
 test/std/containers/views/span.sub/last.pass.cpp       |  4 +++-
 test/std/containers/views/span.sub/subspan.pass.cpp    |  4 +++-
 test/std/containers/views/types.pass.cpp               |  4 +++-
 .../auto.ptr/auto.ptr.cons/assignment.fail.cpp         |  4 +++-
 .../auto.ptr/auto.ptr.cons/assignment.pass.cpp         |  4 +++-
 .../auto.ptr/auto.ptr.cons/convert.fail.cpp            |  4 +++-
 .../auto.ptr/auto.ptr.cons/convert.pass.cpp            |  4 +++-
 .../auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp |  4 +++-
 .../auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp |  4 +++-
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp |  4 +++-
 .../depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp |  4 +++-
 .../auto.ptr/auto.ptr.cons/explicit.fail.cpp           |  4 +++-
 .../auto.ptr/auto.ptr.cons/pointer.pass.cpp            |  4 +++-
 .../auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp    |  4 +++-
 .../auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp   |  4 +++-
 .../auto.ptr.conv/convert_to_auto_ptr.pass.cpp         |  4 +++-
 .../auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp     |  4 +++-
 .../auto.ptr/auto.ptr.members/arrow.pass.cpp           |  4 +++-
 .../auto.ptr/auto.ptr.members/deref.pass.cpp           |  4 +++-
 .../auto.ptr/auto.ptr.members/release.pass.cpp         |  4 +++-
 .../auto.ptr/auto.ptr.members/reset.pass.cpp           |  4 +++-
 .../depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp  |  4 +++-
 test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp     |  4 +++-
 test/std/depr/depr.c.headers/assert_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/ciso646.pass.cpp          |  4 +++-
 test/std/depr/depr.c.headers/complex.h.pass.cpp        |  4 +++-
 test/std/depr/depr.c.headers/ctype_h.pass.cpp          |  4 +++-
 test/std/depr/depr.c.headers/errno_h.pass.cpp          |  4 +++-
 test/std/depr/depr.c.headers/fenv_h.pass.cpp           |  4 +++-
 test/std/depr/depr.c.headers/float_h.pass.cpp          |  4 +++-
 test/std/depr/depr.c.headers/inttypes_h.pass.cpp       |  4 +++-
 test/std/depr/depr.c.headers/iso646_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/limits_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/locale_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/math_h.pass.cpp           |  4 +++-
 test/std/depr/depr.c.headers/setjmp_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/signal_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/stdarg_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/stdbool_h.pass.cpp        |  4 +++-
 test/std/depr/depr.c.headers/stddef_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/stdint_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/stdio_h.pass.cpp          |  4 +++-
 test/std/depr/depr.c.headers/stdlib_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/string_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/tgmath_h.pass.cpp         |  4 +++-
 test/std/depr/depr.c.headers/time_h.pass.cpp           |  4 +++-
 test/std/depr/depr.c.headers/uchar_h.pass.cpp          |  4 +++-
 test/std/depr/depr.c.headers/wchar_h.pass.cpp          |  4 +++-
 test/std/depr/depr.c.headers/wctype_h.pass.cpp         |  4 +++-
 .../pointer_to_binary_function.cxx1z.fail.cpp          |  4 +++-
 .../pointer_to_binary_function.pass.cpp                |  4 +++-
 .../pointer_to_unary_function.cxx1z.fail.cpp           |  4 +++-
 .../pointer_to_unary_function.pass.cpp                 |  4 +++-
 .../ptr_fun1.cxx1z.fail.cpp                            |  4 +++-
 .../depr.function.pointer.adaptors/ptr_fun1.pass.cpp   |  4 +++-
 .../ptr_fun2.cxx1z.fail.cpp                            |  4 +++-
 .../depr.function.pointer.adaptors/ptr_fun2.pass.cpp   |  4 +++-
 .../const_mem_fun.cxx1z.fail.cpp                       |  4 +++-
 .../const_mem_fun.pass.cpp                             |  4 +++-
 .../const_mem_fun1.cxx1z.fail.cpp                      |  4 +++-
 .../const_mem_fun1.pass.cpp                            |  4 +++-
 .../const_mem_fun1_ref_t.cxx1z.fail.cpp                |  4 +++-
 .../const_mem_fun1_ref_t.pass.cpp                      |  4 +++-
 .../const_mem_fun1_t.cxx1z.fail.cpp                    |  4 +++-
 .../const_mem_fun1_t.pass.cpp                          |  4 +++-
 .../const_mem_fun_ref.cxx1z.fail.cpp                   |  4 +++-
 .../const_mem_fun_ref.pass.cpp                         |  4 +++-
 .../const_mem_fun_ref1.cxx1z.fail.cpp                  |  4 +++-
 .../const_mem_fun_ref1.pass.cpp                        |  4 +++-
 .../const_mem_fun_ref_t.cxx1z.fail.cpp                 |  4 +++-
 .../const_mem_fun_ref_t.pass.cpp                       |  4 +++-
 .../const_mem_fun_t.cxx1z.fail.cpp                     |  4 +++-
 .../const_mem_fun_t.pass.cpp                           |  4 +++-
 .../mem_fun.cxx1z.fail.cpp                             |  4 +++-
 .../depr.member.pointer.adaptors/mem_fun.pass.cpp      |  4 +++-
 .../mem_fun1.cxx1z.fail.cpp                            |  4 +++-
 .../depr.member.pointer.adaptors/mem_fun1.pass.cpp     |  4 +++-
 .../mem_fun1_ref_t.cxx1z.fail.cpp                      |  4 +++-
 .../mem_fun1_ref_t.pass.cpp                            |  4 +++-
 .../mem_fun1_t.cxx1z.fail.cpp                          |  4 +++-
 .../depr.member.pointer.adaptors/mem_fun1_t.pass.cpp   |  4 +++-
 .../mem_fun_ref.cxx1z.fail.cpp                         |  4 +++-
 .../depr.member.pointer.adaptors/mem_fun_ref.pass.cpp  |  4 +++-
 .../mem_fun_ref1.cxx1z.fail.cpp                        |  4 +++-
 .../depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp |  4 +++-
 .../mem_fun_ref_t.cxx1z.fail.cpp                       |  4 +++-
 .../mem_fun_ref_t.pass.cpp                             |  4 +++-
 .../mem_fun_t.cxx1z.fail.cpp                           |  4 +++-
 .../depr.member.pointer.adaptors/mem_fun_t.pass.cpp    |  4 +++-
 .../depr.adaptors/nothing_to_do.pass.cpp               |  4 +++-
 .../depr.base/binary_function.pass.cpp                 |  4 +++-
 .../depr.base/unary_function.pass.cpp                  |  4 +++-
 .../depr/depr.function.objects/nothing_to_do.pass.cpp  |  4 +++-
 test/std/depr/depr.ios.members/io_state.pass.cpp       |  4 +++-
 test/std/depr/depr.ios.members/open_mode.pass.cpp      |  4 +++-
 test/std/depr/depr.ios.members/seek_dir.pass.cpp       |  4 +++-
 test/std/depr/depr.ios.members/streamoff.pass.cpp      |  4 +++-
 test/std/depr/depr.ios.members/streampos.pass.cpp      |  4 +++-
 .../depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp   |  4 +++-
 .../depr.lib.bind.1st/bind1st.pass.cpp                 |  4 +++-
 .../depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp   |  4 +++-
 .../depr.lib.bind.2nd/bind2nd.pass.cpp                 |  4 +++-
 .../binder1st.depr_in_cxx11.fail.cpp                   |  4 +++-
 .../depr.lib.binder.1st/binder1st.pass.cpp             |  4 +++-
 .../binder2nd.depr_in_cxx11.fail.cpp                   |  4 +++-
 .../depr.lib.binder.2nd/binder2nd.pass.cpp             |  4 +++-
 test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp  |  4 +++-
 .../depr.istrstream/depr.istrstream.cons/ccp.pass.cpp  |  4 +++-
 .../depr.istrstream.cons/ccp_size.pass.cpp             |  4 +++-
 .../depr.istrstream/depr.istrstream.cons/cp.pass.cpp   |  4 +++-
 .../depr.istrstream.cons/cp_size.pass.cpp              |  4 +++-
 .../depr.istrstream.members/rdbuf.pass.cpp             |  4 +++-
 .../depr.istrstream.members/str.pass.cpp               |  4 +++-
 .../depr.str.strstreams/depr.istrstream/types.pass.cpp |  4 +++-
 .../depr.ostrstream.cons/cp_size_mode.pass.cpp         |  4 +++-
 .../depr.ostrstream.cons/default.pass.cpp              |  4 +++-
 .../depr.ostrstream.members/freeze.pass.cpp            |  4 +++-
 .../depr.ostrstream.members/pcount.pass.cpp            |  4 +++-
 .../depr.ostrstream.members/rdbuf.pass.cpp             |  4 +++-
 .../depr.ostrstream.members/str.pass.cpp               |  4 +++-
 .../depr.str.strstreams/depr.ostrstream/types.pass.cpp |  4 +++-
 .../depr.strstream.cons/cp_size_mode.pass.cpp          |  4 +++-
 .../depr.strstream.cons/default.pass.cpp               |  4 +++-
 .../depr.strstream/depr.strstream.dest/rdbuf.pass.cpp  |  4 +++-
 .../depr.strstream/depr.strstream.oper/freeze.pass.cpp |  4 +++-
 .../depr.strstream/depr.strstream.oper/pcount.pass.cpp |  4 +++-
 .../depr.strstream/depr.strstream.oper/str.pass.cpp    |  4 +++-
 .../depr.str.strstreams/depr.strstream/types.pass.cpp  |  4 +++-
 .../depr.strstreambuf.cons/ccp_size.pass.cpp           |  4 +++-
 .../depr.strstreambuf.cons/cp_size_cp.pass.cpp         |  4 +++-
 .../depr.strstreambuf.cons/cscp_size.pass.cpp          |  4 +++-
 .../depr.strstreambuf.cons/cucp_size.pass.cpp          |  4 +++-
 .../depr.strstreambuf.cons/custom_alloc.pass.cpp       |  4 +++-
 .../depr.strstreambuf.cons/default.pass.cpp            |  4 +++-
 .../depr.strstreambuf.cons/scp_size_scp.pass.cpp       |  4 +++-
 .../depr.strstreambuf.cons/ucp_size_ucp.pass.cpp       |  4 +++-
 .../depr.strstreambuf.members/freeze.pass.cpp          |  4 +++-
 .../depr.strstreambuf.members/overflow.pass.cpp        |  2 +-
 .../depr.strstreambuf.members/pcount.pass.cpp          |  4 +++-
 .../depr.strstreambuf.members/str.pass.cpp             |  4 +++-
 .../depr.strstreambuf.virtuals/overflow.pass.cpp       |  4 +++-
 .../depr.strstreambuf.virtuals/pbackfail.pass.cpp      |  4 +++-
 .../depr.strstreambuf.virtuals/seekoff.pass.cpp        |  4 +++-
 .../depr.strstreambuf.virtuals/seekpos.pass.cpp        |  4 +++-
 .../depr.strstreambuf.virtuals/setbuf.pass.cpp         |  4 +++-
 .../depr.strstreambuf.virtuals/underflow.pass.cpp      |  4 +++-
 .../depr.strstreambuf/types.pass.cpp                   |  4 +++-
 .../depr/exception.unexpected/nothing_to_do.pass.cpp   |  4 +++-
 .../set.unexpected/get_unexpected.pass.cpp             |  4 +++-
 .../set.unexpected/set_unexpected.pass.cpp             |  4 +++-
 .../unexpected.handler/unexpected_handler.pass.cpp     |  4 +++-
 .../unexpected/unexpected.pass.cpp                     |  4 +++-
 test/std/depr/nothing_to_do.pass.cpp                   |  4 +++-
 test/std/diagnostics/assertions/cassert.pass.cpp       |  4 +++-
 .../diagnostics.general/nothing_to_do.pass.cpp         |  4 +++-
 test/std/diagnostics/errno/cerrno.pass.cpp             |  4 +++-
 test/std/diagnostics/nothing_to_do.pass.cpp            |  4 +++-
 .../std.exceptions/domain.error/domain_error.pass.cpp  |  4 +++-
 .../invalid.argument/invalid_argument.pass.cpp         |  4 +++-
 .../std.exceptions/length.error/length_error.pass.cpp  |  4 +++-
 .../std.exceptions/logic.error/logic_error.pass.cpp    |  4 +++-
 .../std.exceptions/out.of.range/out_of_range.pass.cpp  |  4 +++-
 .../overflow.error/overflow_error.pass.cpp             |  4 +++-
 .../std.exceptions/range.error/range_error.pass.cpp    |  4 +++-
 .../runtime.error/runtime_error.pass.cpp               |  4 +++-
 .../underflow.error/underflow_error.pass.cpp           |  4 +++-
 test/std/diagnostics/syserr/errc.pass.cpp              |  4 +++-
 .../std/diagnostics/syserr/is_error_code_enum.pass.cpp |  4 +++-
 .../syserr/is_error_condition_enum.pass.cpp            |  4 +++-
 .../syserr.compare/eq_error_code_error_code.pass.cpp   |  4 +++-
 .../syserr/syserr.errcat/nothing_to_do.pass.cpp        |  4 +++-
 .../syserr.errcat.derived/message.pass.cpp             |  4 +++-
 .../syserr.errcat.nonvirtuals/default_ctor.pass.cpp    |  4 +++-
 .../syserr.errcat.nonvirtuals/eq.pass.cpp              |  4 +++-
 .../syserr.errcat.nonvirtuals/lt.pass.cpp              |  4 +++-
 .../syserr.errcat.nonvirtuals/neq.pass.cpp             |  4 +++-
 .../syserr.errcat.objects/generic_category.pass.cpp    |  4 +++-
 .../syserr.errcat.objects/system_category.pass.cpp     |  4 +++-
 .../syserr.errcat.overview/error_category.pass.cpp     |  4 +++-
 .../default_error_condition.pass.cpp                   |  4 +++-
 .../equivalent_error_code_int.pass.cpp                 |  4 +++-
 .../equivalent_int_error_condition.pass.cpp            |  4 +++-
 .../syserr/syserr.errcode/nothing_to_do.pass.cpp       |  4 +++-
 .../syserr.errcode.constructors/ErrorCodeEnum.pass.cpp |  4 +++-
 .../syserr.errcode.constructors/default.pass.cpp       |  4 +++-
 .../int_error_category.pass.cpp                        |  4 +++-
 .../syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp    |  4 +++-
 .../syserr.errcode.modifiers/assign.pass.cpp           |  4 +++-
 .../syserr.errcode.modifiers/clear.pass.cpp            |  4 +++-
 .../syserr.errcode.nonmembers/lt.pass.cpp              |  4 +++-
 .../syserr.errcode.nonmembers/make_error_code.pass.cpp |  4 +++-
 .../syserr.errcode.nonmembers/stream_inserter.pass.cpp |  4 +++-
 .../syserr.errcode.observers/bool.fail.cpp             |  2 +-
 .../syserr.errcode.observers/bool.pass.cpp             |  4 +++-
 .../syserr.errcode.observers/category.pass.cpp         |  4 +++-
 .../default_error_condition.pass.cpp                   |  4 +++-
 .../syserr.errcode.observers/message.pass.cpp          |  4 +++-
 .../syserr.errcode.observers/value.pass.cpp            |  4 +++-
 .../syserr.errcode.overview/types.pass.cpp             |  4 +++-
 .../syserr/syserr.errcondition/nothing_to_do.pass.cpp  |  4 +++-
 .../ErrorConditionEnum.pass.cpp                        |  4 +++-
 .../syserr.errcondition.constructors/default.pass.cpp  |  4 +++-
 .../int_error_category.pass.cpp                        |  4 +++-
 .../ErrorConditionEnum.pass.cpp                        |  4 +++-
 .../syserr.errcondition.modifiers/assign.pass.cpp      |  4 +++-
 .../syserr.errcondition.modifiers/clear.pass.cpp       |  4 +++-
 .../syserr.errcondition.nonmembers/lt.pass.cpp         |  4 +++-
 .../make_error_condition.pass.cpp                      |  4 +++-
 .../syserr.errcondition.observers/bool.pass.cpp        |  4 +++-
 .../syserr.errcondition.observers/category.pass.cpp    |  4 +++-
 .../syserr.errcondition.observers/message.pass.cpp     |  4 +++-
 .../syserr.errcondition.observers/value.pass.cpp       |  4 +++-
 .../syserr.errcondition.overview/types.pass.cpp        |  4 +++-
 .../syserr/syserr.hash/enabled_hash.pass.cpp           |  4 +++-
 .../diagnostics/syserr/syserr.hash/error_code.pass.cpp |  4 +++-
 .../syserr/syserr.hash/error_condition.pass.cpp        |  4 +++-
 .../syserr/syserr.syserr/nothing_to_do.pass.cpp        |  4 +++-
 .../syserr.syserr.members/ctor_error_code.pass.cpp     |  4 +++-
 .../ctor_error_code_const_char_pointer.pass.cpp        |  4 +++-
 .../ctor_error_code_string.pass.cpp                    |  4 +++-
 .../ctor_int_error_category.pass.cpp                   |  4 +++-
 ...ctor_int_error_category_const_char_pointer.pass.cpp |  4 +++-
 .../ctor_int_error_category_string.pass.cpp            |  4 +++-
 .../syserr.syserr.overview/nothing_to_do.pass.cpp      |  4 +++-
 .../experimental/algorithms/alg.search/search.pass.cpp |  4 +++-
 .../filesystem/fs.req.macros/feature_macro.pass.cpp    |  4 +++-
 .../filesystem/fs.req.namespace/namespace.pass.cpp     |  4 +++-
 .../func.searchers.boyer_moore/default.pass.cpp        |  4 +++-
 .../func.searchers.boyer_moore/hash.pass.cpp           |  4 +++-
 .../func.searchers.boyer_moore/hash.pred.pass.cpp      |  4 +++-
 .../func.searchers.boyer_moore/pred.pass.cpp           |  4 +++-
 .../default.pass.cpp                                   |  4 +++-
 .../func.searchers.boyer_moore_horspool/hash.pass.cpp  |  4 +++-
 .../hash.pred.pass.cpp                                 |  4 +++-
 .../func.searchers.boyer_moore_horspool/pred.pass.cpp  |  4 +++-
 .../func.searchers.default/default.pass.cpp            |  4 +++-
 .../func.searchers.default/default.pred.pass.cpp       |  4 +++-
 .../make_default_searcher.pass.cpp                     |  4 +++-
 .../make_default_searcher.pred.pass.cpp                |  4 +++-
 .../func/func.searchers/nothing_to_do.pass.cpp         |  4 +++-
 .../func/header.functional.synop/includes.pass.cpp     |  4 +++-
 test/std/experimental/func/nothing_to_do.pass.cpp      |  4 +++-
 test/std/experimental/iterator/nothing_to_do.pass.cpp  |  4 +++-
 .../ostream.joiner.cons/ostream_joiner.cons.pass.cpp   |  6 ++++--
 .../make_ostream_joiner.pass.cpp                       |  6 ++++--
 .../ostream_joiner.op.assign.pass.cpp                  |  4 +++-
 .../ostream_joiner.op.postincrement.pass.cpp           |  6 ++++--
 .../ostream_joiner.op.pretincrement.pass.cpp           |  6 ++++--
 .../ostream.joiner.ops/ostream_joiner.op.star.pass.cpp |  6 ++++--
 .../coroutine.handle.capacity/operator_bool.pass.cpp   |  4 +++-
 .../coroutine.handle.compare/equal_comp.pass.cpp       |  4 +++-
 .../coroutine.handle.compare/less_comp.pass.cpp        |  4 +++-
 .../coroutine.handle.completion/done.pass.cpp          |  4 +++-
 .../coroutine.handle.con/assign.pass.cpp               |  4 +++-
 .../coroutine.handle.con/construct.pass.cpp            |  4 +++-
 .../coroutine.handle.export/address.pass.cpp           |  4 +++-
 .../coroutine.handle.export/from_address.fail.cpp      |  4 +++-
 .../coroutine.handle.export/from_address.pass.cpp      |  4 +++-
 .../coroutine.handle.hash/hash.pass.cpp                |  4 +++-
 .../coroutine.handle.noop/noop_coroutine.pass.cpp      |  6 ++++--
 .../coroutine.handle.prom/promise.pass.cpp             |  4 +++-
 .../coroutine.handle.resumption/destroy.pass.cpp       |  4 +++-
 .../coroutine.handle.resumption/resume.pass.cpp        |  4 +++-
 .../coroutine.handle/void_handle.pass.cpp              |  4 +++-
 .../coroutine.traits/promise_type.pass.cpp             |  4 +++-
 .../suspend_always.pass.cpp                            |  4 +++-
 .../suspend_never.pass.cpp                             |  4 +++-
 .../end.to.end/await_result.pass.cpp                   |  4 +++-
 .../end.to.end/bool_await_suspend.pass.cpp             |  4 +++-
 .../support.coroutines/end.to.end/expected.pass.cpp    |  4 +++-
 .../end.to.end/fullexpr-dtor.pass.cpp                  |  4 +++-
 .../support.coroutines/end.to.end/generator.pass.cpp   |  4 +++-
 .../support.coroutines/end.to.end/go.pass.cpp          |  4 +++-
 .../end.to.end/multishot_func.pass.cpp                 |  4 +++-
 .../end.to.end/oneshot_func.pass.cpp                   |  4 +++-
 .../support.coroutines/includes.pass.cpp               |  3 ++-
 .../memory.polymorphic.allocator.ctor/assign.pass.cpp  |  4 +++-
 .../memory.polymorphic.allocator.ctor/copy.pass.cpp    |  4 +++-
 .../memory.polymorphic.allocator.ctor/default.pass.cpp |  4 +++-
 .../memory_resource_convert.pass.cpp                   |  4 +++-
 .../other_alloc.pass.cpp                               |  4 +++-
 .../memory.polymorphic.allocator.eq/equal.pass.cpp     |  4 +++-
 .../memory.polymorphic.allocator.eq/not_equal.pass.cpp |  4 +++-
 .../memory.polymorphic.allocator.mem/allocate.pass.cpp |  4 +++-
 .../construct_pair.pass.cpp                            |  4 +++-
 .../construct_pair_const_lvalue_pair.pass.cpp          |  4 +++-
 .../construct_pair_rvalue.pass.cpp                     |  4 +++-
 .../construct_pair_values.pass.cpp                     |  4 +++-
 .../construct_piecewise_pair.pass.cpp                  |  4 +++-
 .../construct_piecewise_pair_evil.pass.cpp             |  4 +++-
 .../construct_types.pass.cpp                           |  4 +++-
 .../deallocate.pass.cpp                                |  4 +++-
 .../memory.polymorphic.allocator.mem/destroy.pass.cpp  |  4 +++-
 .../memory.polymorphic.allocator.mem/resource.pass.cpp |  4 +++-
 .../select_on_container_copy_construction.pass.cpp     |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../memory.resource.adaptor.ctor/alloc_copy.pass.cpp   |  4 +++-
 .../memory.resource.adaptor.ctor/alloc_move.pass.cpp   |  4 +++-
 .../memory.resource.adaptor.ctor/default.pass.cpp      |  4 +++-
 .../do_allocate_and_deallocate.pass.cpp                |  4 +++-
 .../memory.resource.adaptor.mem/do_is_equal.pass.cpp   |  4 +++-
 .../memory.resource.adaptor.overview/overview.pass.cpp |  4 +++-
 .../header_deque_synop.pass.cpp                        |  4 +++-
 .../header_forward_list_synop.pass.cpp                 |  4 +++-
 .../memory.resource.aliases/header_list_synop.pass.cpp |  4 +++-
 .../memory.resource.aliases/header_map_synop.pass.cpp  |  4 +++-
 .../header_regex_synop.pass.cpp                        |  4 +++-
 .../memory.resource.aliases/header_set_synop.pass.cpp  |  4 +++-
 .../header_string_synop.pass.cpp                       |  4 +++-
 .../header_unordered_map_synop.pass.cpp                |  4 +++-
 .../header_unordered_set_synop.pass.cpp                |  4 +++-
 .../header_vector_synop.pass.cpp                       |  4 +++-
 .../memory.resource.global/default_resource.pass.cpp   |  4 +++-
 .../new_delete_resource.pass.cpp                       |  4 +++-
 .../null_memory_resource.pass.cpp                      |  4 +++-
 .../memory.resource.synop/nothing_to_do.pass.cpp       |  4 +++-
 .../memory/memory.resource/construct.fail.cpp          |  4 +++-
 .../memory.resource/memory.resource.eq/equal.pass.cpp  |  4 +++-
 .../memory.resource.eq/not_equal.pass.cpp              |  4 +++-
 .../memory.resource.overview/nothing_to_do.pass.cpp    |  4 +++-
 .../memory.resource.priv/protected_members.fail.cpp    |  4 +++-
 .../memory.resource.public/allocate.pass.cpp           |  4 +++-
 .../memory.resource.public/deallocate.pass.cpp         |  4 +++-
 .../memory.resource.public/dtor.pass.cpp               |  4 +++-
 .../memory.resource.public/is_equal.pass.cpp           |  4 +++-
 test/std/experimental/memory/nothing_to_do.pass.cpp    |  4 +++-
 test/std/experimental/nothing_to_do.pass.cpp           |  4 +++-
 .../simd/simd.abi/vector_extension.pass.cpp            |  4 +++-
 .../std/experimental/simd/simd.access/default.pass.cpp |  4 +++-
 .../experimental/simd/simd.casts/simd_cast.pass.cpp    |  4 +++-
 .../simd/simd.casts/static_simd_cast.pass.cpp          |  4 +++-
 .../std/experimental/simd/simd.cons/broadcast.pass.cpp |  4 +++-
 test/std/experimental/simd/simd.cons/default.pass.cpp  |  4 +++-
 .../std/experimental/simd/simd.cons/generator.pass.cpp |  4 +++-
 test/std/experimental/simd/simd.cons/load.pass.cpp     |  4 +++-
 test/std/experimental/simd/simd.mem/load.pass.cpp      |  4 +++-
 test/std/experimental/simd/simd.mem/store.pass.cpp     |  4 +++-
 .../simd/simd.traits/abi_for_size.pass.cpp             |  4 +++-
 .../experimental/simd/simd.traits/is_abi_tag.pass.cpp  |  4 +++-
 .../std/experimental/simd/simd.traits/is_simd.pass.cpp |  4 +++-
 .../simd/simd.traits/is_simd_flag_type.pass.cpp        |  4 +++-
 .../simd/simd.traits/is_simd_mask.pass.cpp             |  4 +++-
 .../utilities/meta/meta.detect/detected_or.pass.cpp    |  4 +++-
 .../utilities/meta/meta.detect/detected_t.pass.cpp     |  4 +++-
 .../utilities/meta/meta.detect/is_detected.pass.cpp    |  4 +++-
 .../meta/meta.detect/is_detected_convertible.pass.cpp  |  4 +++-
 .../meta/meta.detect/is_detected_exact.pass.cpp        |  4 +++-
 test/std/experimental/utilities/nothing_to_do.pass.cpp |  4 +++-
 .../propagate_const.assignment/assign.pass.cpp         |  4 +++-
 .../assign_convertible_element_type.pass.cpp           |  4 +++-
 .../assign_convertible_propagate_const.pass.cpp        |  4 +++-
 .../assign_element_type.pass.cpp                       |  4 +++-
 .../propagate_const.assignment/move_assign.pass.cpp    |  4 +++-
 .../move_assign_convertible.pass.cpp                   |  4 +++-
 .../move_assign_convertible_propagate_const.pass.cpp   |  4 +++-
 .../convertible_element_type.explicit.ctor.pass.cpp    |  4 +++-
 ...convertible_element_type.non-explicit.ctor.pass.cpp |  4 +++-
 .../convertible_propagate_const.copy_ctor.pass.cpp     |  4 +++-
 ...ertible_propagate_const.explicit.move_ctor.pass.cpp |  4 +++-
 .../convertible_propagate_const.move_ctor.pass.cpp     |  4 +++-
 .../propagate_const.ctors/copy_ctor.pass.cpp           |  4 +++-
 .../element_type.explicit.ctor.pass.cpp                |  4 +++-
 .../element_type.non-explicit.ctor.pass.cpp            |  4 +++-
 .../propagate_const.ctors/move_ctor.pass.cpp           |  4 +++-
 .../dereference.pass.cpp                               |  4 +++-
 .../explicit_operator_element_type_ptr.pass.cpp        |  4 +++-
 .../propagate_const.non-const_observers/get.pass.cpp   |  4 +++-
 .../op_arrow.pass.cpp                                  |  4 +++-
 .../operator_element_type_ptr.pass.cpp                 |  4 +++-
 .../propagate_const.observers/dereference.pass.cpp     |  4 +++-
 .../explicit_operator_element_type_ptr.pass.cpp        |  4 +++-
 .../propagate_const.observers/get.pass.cpp             |  4 +++-
 .../propagate_const.observers/op_arrow.pass.cpp        |  4 +++-
 .../operator_element_type_ptr.pass.cpp                 |  4 +++-
 .../propagate_const.class/swap.pass.cpp                |  4 +++-
 .../propagate_const.nonmembers/hash.pass.cpp           |  4 +++-
 .../equal_to.pass.cpp                                  |  4 +++-
 .../greater.pass.cpp                                   |  4 +++-
 .../greater_equal.pass.cpp                             |  4 +++-
 .../less.pass.cpp                                      |  4 +++-
 .../less_equal.pass.cpp                                |  4 +++-
 .../not_equal_to.pass.cpp                              |  4 +++-
 .../propagate_const.relops/equal.pass.cpp              |  4 +++-
 .../propagate_const.relops/greater_equal.pass.cpp      |  4 +++-
 .../propagate_const.relops/greater_than.pass.cpp       |  4 +++-
 .../propagate_const.relops/less_equal.pass.cpp         |  4 +++-
 .../propagate_const.relops/less_than.pass.cpp          |  4 +++-
 .../propagate_const.relops/not_equal.pass.cpp          |  4 +++-
 .../propagate_const.nonmembers/swap.pass.cpp           |  4 +++-
 .../utility/utility.erased.type/erased_type.pass.cpp   |  4 +++-
 .../utilities/utility/utility.synop/includes.pass.cpp  |  4 +++-
 .../file.streams/c.files/cinttypes.pass.cpp            |  4 +++-
 .../input.output/file.streams/c.files/cstdio.pass.cpp  |  4 +++-
 .../input.output/file.streams/c.files/gets.fail.cpp    |  4 +++-
 .../fstreams/filebuf.assign/member_swap.pass.cpp       |  4 +++-
 .../fstreams/filebuf.assign/move_assign.pass.cpp       |  4 +++-
 .../fstreams/filebuf.assign/nonmember_swap.pass.cpp    |  4 +++-
 .../fstreams/filebuf.cons/default.pass.cpp             |  4 +++-
 .../file.streams/fstreams/filebuf.cons/move.pass.cpp   |  4 +++-
 .../fstreams/filebuf.members/open_path.pass.cpp        |  4 +++-
 .../fstreams/filebuf.members/open_pointer.pass.cpp     |  4 +++-
 .../fstreams/filebuf.virtuals/overflow.pass.cpp        |  4 +++-
 .../fstreams/filebuf.virtuals/pbackfail.pass.cpp       |  4 +++-
 .../fstreams/filebuf.virtuals/seekoff.pass.cpp         |  4 +++-
 .../fstreams/filebuf.virtuals/underflow.pass.cpp       |  4 +++-
 .../file.streams/fstreams/filebuf/types.pass.cpp       |  4 +++-
 .../fstreams/fstream.assign/member_swap.pass.cpp       |  4 +++-
 .../fstreams/fstream.assign/move_assign.pass.cpp       |  4 +++-
 .../fstreams/fstream.assign/nonmember_swap.pass.cpp    |  4 +++-
 .../fstreams/fstream.cons/default.pass.cpp             |  4 +++-
 .../file.streams/fstreams/fstream.cons/move.pass.cpp   |  4 +++-
 .../file.streams/fstreams/fstream.cons/path.pass.cpp   |  4 +++-
 .../fstreams/fstream.cons/pointer.pass.cpp             |  4 +++-
 .../file.streams/fstreams/fstream.cons/string.pass.cpp |  4 +++-
 .../fstreams/fstream.members/close.pass.cpp            |  4 +++-
 .../fstreams/fstream.members/open_path.pass.cpp        |  4 +++-
 .../fstreams/fstream.members/open_pointer.pass.cpp     |  4 +++-
 .../fstreams/fstream.members/open_string.pass.cpp      |  4 +++-
 .../fstreams/fstream.members/rdbuf.pass.cpp            |  4 +++-
 .../file.streams/fstreams/fstream/types.pass.cpp       |  4 +++-
 .../fstreams/ifstream.assign/member_swap.pass.cpp      |  4 +++-
 .../fstreams/ifstream.assign/move_assign.pass.cpp      |  4 +++-
 .../fstreams/ifstream.assign/nonmember_swap.pass.cpp   |  4 +++-
 .../fstreams/ifstream.cons/default.pass.cpp            |  4 +++-
 .../file.streams/fstreams/ifstream.cons/move.pass.cpp  |  4 +++-
 .../file.streams/fstreams/ifstream.cons/path.pass.cpp  |  4 +++-
 .../fstreams/ifstream.cons/pointer.pass.cpp            |  4 +++-
 .../fstreams/ifstream.cons/string.pass.cpp             |  4 +++-
 .../fstreams/ifstream.members/close.pass.cpp           |  4 +++-
 .../fstreams/ifstream.members/open_path.pass.cpp       |  4 +++-
 .../fstreams/ifstream.members/open_pointer.pass.cpp    |  4 +++-
 .../fstreams/ifstream.members/open_string.pass.cpp     |  4 +++-
 .../fstreams/ifstream.members/rdbuf.pass.cpp           |  4 +++-
 .../file.streams/fstreams/ifstream/types.pass.cpp      |  4 +++-
 .../fstreams/ofstream.assign/member_swap.pass.cpp      |  4 +++-
 .../fstreams/ofstream.assign/move_assign.pass.cpp      |  4 +++-
 .../fstreams/ofstream.assign/nonmember_swap.pass.cpp   |  4 +++-
 .../fstreams/ofstream.cons/default.pass.cpp            |  4 +++-
 .../file.streams/fstreams/ofstream.cons/move.pass.cpp  |  4 +++-
 .../file.streams/fstreams/ofstream.cons/path.pass.cpp  |  4 +++-
 .../fstreams/ofstream.cons/pointer.pass.cpp            |  4 +++-
 .../fstreams/ofstream.cons/string.pass.cpp             |  4 +++-
 .../fstreams/ofstream.members/close.pass.cpp           |  4 +++-
 .../fstreams/ofstream.members/open_path.pass.cpp       |  4 +++-
 .../fstreams/ofstream.members/open_pointer.pass.cpp    |  4 +++-
 .../fstreams/ofstream.members/open_string.pass.cpp     |  4 +++-
 .../fstreams/ofstream.members/rdbuf.pass.cpp           |  4 +++-
 .../file.streams/fstreams/ofstream/types.pass.cpp      |  4 +++-
 .../input.output/file.streams/nothing_to_do.pass.cpp   |  4 +++-
 .../directory_entry.cons/default.pass.cpp              |  4 +++-
 .../directory_entry.cons/default_const.pass.cpp        |  4 +++-
 .../directory_entry.obs/comparisons.pass.cpp           |  4 +++-
 .../directory_entry.obs/path.pass.cpp                  |  4 +++-
 .../directory_iterator.members/default_ctor.pass.cpp   |  4 +++-
 .../class.directory_iterator/types.pass.cpp            |  4 +++-
 .../class.file_status/file_status.cons.pass.cpp        |  4 +++-
 .../class.file_status/file_status.mods.pass.cpp        |  4 +++-
 .../class.file_status/file_status.obs.pass.cpp         |  4 +++-
 .../filesystem_error.members.pass.cpp                  |  4 +++-
 .../filesystems/class.path/path.itr/iterator.pass.cpp  |  4 +++-
 .../class.path/path.member/path.append.pass.cpp        |  4 +++-
 .../path.member/path.assign/braced_init.pass.cpp       |  4 +++-
 .../class.path/path.member/path.assign/copy.pass.cpp   |  4 +++-
 .../class.path/path.member/path.assign/move.pass.cpp   |  4 +++-
 .../class.path/path.member/path.assign/source.pass.cpp |  4 +++-
 .../class.path/path.member/path.compare.pass.cpp       |  4 +++-
 .../class.path/path.member/path.concat.pass.cpp        |  4 +++-
 .../path.member/path.construct/copy.pass.cpp           |  4 +++-
 .../path.member/path.construct/default.pass.cpp        |  4 +++-
 .../path.member/path.construct/move.pass.cpp           |  4 +++-
 .../path.member/path.construct/source.pass.cpp         |  4 +++-
 .../path.member/path.decompose/empty.fail.cpp          |  4 +++-
 .../path.member/path.decompose/path.decompose.pass.cpp |  4 +++-
 .../path.member/path.gen/lexically_normal.pass.cpp     |  2 +-
 .../path.gen/lexically_relative_and_proximate.pass.cpp |  2 +-
 .../path.generic.obs/generic_string_alloc.pass.cpp     |  4 +++-
 .../path.generic.obs/named_overloads.pass.cpp          |  4 +++-
 .../path.member/path.modifiers/clear.pass.cpp          |  4 +++-
 .../path.member/path.modifiers/make_preferred.pass.cpp |  4 +++-
 .../path.modifiers/remove_filename.pass.cpp            |  4 +++-
 .../path.modifiers/replace_extension.pass.cpp          |  4 +++-
 .../path.modifiers/replace_filename.pass.cpp           |  4 +++-
 .../path.member/path.modifiers/swap.pass.cpp           |  4 +++-
 .../path.member/path.native.obs/c_str.pass.cpp         |  4 +++-
 .../path.native.obs/named_overloads.pass.cpp           |  4 +++-
 .../path.member/path.native.obs/native.pass.cpp        |  4 +++-
 .../path.native.obs/operator_string.pass.cpp           |  4 +++-
 .../path.member/path.native.obs/string_alloc.pass.cpp  |  4 +++-
 .../path.query/tested_in_path_decompose.pass.cpp       |  4 +++-
 .../class.path/path.nonmember/append_op.fail.cpp       |  4 +++-
 .../class.path/path.nonmember/append_op.pass.cpp       |  4 +++-
 .../class.path/path.nonmember/comparison_ops.fail.cpp  |  4 +++-
 .../comparison_ops_tested_elsewhere.pass.cpp           |  4 +++-
 .../path.nonmember/hash_value_tested_elswhere.pass.cpp |  4 +++-
 .../class.path/path.nonmember/path.factory.pass.cpp    |  4 +++-
 .../class.path/path.nonmember/path.io.pass.cpp         |  4 +++-
 .../path.nonmember/path.io.unicode_bug.pass.cpp        |  4 +++-
 .../class.path/path.nonmember/swap.pass.cpp            |  4 +++-
 .../input.output/filesystems/class.path/synop.pass.cpp |  4 +++-
 .../filesystems/fs.enum/enum.copy_options.pass.cpp     |  4 +++-
 .../fs.enum/enum.directory_options.pass.cpp            |  4 +++-
 .../filesystems/fs.enum/enum.file_type.pass.cpp        |  4 +++-
 .../filesystems/fs.enum/enum.path.format.pass.cpp      |  4 +++-
 .../filesystems/fs.enum/enum.perm_options.pass.cpp     |  4 +++-
 .../filesystems/fs.enum/enum.perms.pass.cpp            |  4 +++-
 .../fs.error.report/tested_elsewhere.pass.cpp          |  4 +++-
 .../fs.filesystem.synopsis/file_time_type.pass.cpp     |  4 +++-
 .../fs.op.weakly_canonical/weakly_canonical.pass.cpp   |  2 +-
 .../filesystems/fs.req.macros/feature_macro.pass.cpp   |  4 +++-
 .../filesystems/fs.req.namespace/namespace.fail.cpp    |  4 +++-
 .../filesystems/fs.req.namespace/namespace.pass.cpp    |  4 +++-
 .../input.output.general/nothing_to_do.pass.cpp        |  4 +++-
 .../iostream.format/ext.manip/get_money.pass.cpp       |  4 +++-
 .../iostream.format/ext.manip/get_time.pass.cpp        |  4 +++-
 .../iostream.format/ext.manip/put_money.pass.cpp       |  4 +++-
 .../iostream.format/ext.manip/put_time.pass.cpp        |  4 +++-
 .../iostreamclass/iostream.assign/member_swap.pass.cpp |  4 +++-
 .../iostreamclass/iostream.assign/move_assign.pass.cpp |  4 +++-
 .../iostreamclass/iostream.cons/move.pass.cpp          |  4 +++-
 .../iostreamclass/iostream.cons/streambuf.pass.cpp     |  4 +++-
 .../iostreamclass/iostream.dest/nothing_to_do.pass.cpp |  4 +++-
 .../input.streams/iostreamclass/types.pass.cpp         |  4 +++-
 .../istream.formatted.arithmetic/bool.pass.cpp         |  4 +++-
 .../istream.formatted.arithmetic/double.pass.cpp       |  4 +++-
 .../istream.formatted.arithmetic/float.pass.cpp        |  4 +++-
 .../istream.formatted.arithmetic/int.pass.cpp          |  4 +++-
 .../istream.formatted.arithmetic/long.pass.cpp         |  4 +++-
 .../istream.formatted.arithmetic/long_double.pass.cpp  |  4 +++-
 .../istream.formatted.arithmetic/long_long.pass.cpp    |  4 +++-
 .../istream.formatted.arithmetic/pointer.pass.cpp      |  4 +++-
 .../istream.formatted.arithmetic/short.pass.cpp        |  4 +++-
 .../istream.formatted.arithmetic/unsigned_int.pass.cpp |  4 +++-
 .../unsigned_long.pass.cpp                             |  4 +++-
 .../unsigned_long_long.pass.cpp                        |  4 +++-
 .../unsigned_short.pass.cpp                            |  4 +++-
 .../istream.formatted.reqmts/tested_elsewhere.pass.cpp |  4 +++-
 .../istream_extractors/basic_ios.pass.cpp              |  4 +++-
 .../istream_extractors/chart.pass.cpp                  |  4 +++-
 .../istream_extractors/ios_base.pass.cpp               |  4 +++-
 .../istream_extractors/istream.pass.cpp                |  4 +++-
 .../istream_extractors/signed_char.pass.cpp            |  4 +++-
 .../istream_extractors/signed_char_pointer.pass.cpp    |  4 +++-
 .../istream_extractors/streambuf.pass.cpp              |  4 +++-
 .../istream_extractors/unsigned_char.pass.cpp          |  4 +++-
 .../istream_extractors/unsigned_char_pointer.pass.cpp  |  4 +++-
 .../istream_extractors/wchar_t_pointer.pass.cpp        |  4 +++-
 .../istream.formatted/nothing_to_do.pass.cpp           |  4 +++-
 .../input.streams/istream.manip/ws.pass.cpp            |  4 +++-
 .../input.streams/istream.rvalue/rvalue.pass.cpp       |  4 +++-
 .../input.streams/istream.unformatted/get.pass.cpp     |  4 +++-
 .../istream.unformatted/get_chart.pass.cpp             |  4 +++-
 .../istream.unformatted/get_pointer_size.pass.cpp      |  4 +++-
 .../get_pointer_size_chart.pass.cpp                    |  4 +++-
 .../istream.unformatted/get_streambuf.pass.cpp         |  4 +++-
 .../istream.unformatted/get_streambuf_chart.pass.cpp   |  4 +++-
 .../istream.unformatted/getline_pointer_size.pass.cpp  |  4 +++-
 .../getline_pointer_size_chart.pass.cpp                |  4 +++-
 .../input.streams/istream.unformatted/ignore.pass.cpp  |  4 +++-
 .../istream.unformatted/ignore_0xff.pass.cpp           |  4 +++-
 .../input.streams/istream.unformatted/peek.pass.cpp    |  4 +++-
 .../input.streams/istream.unformatted/putback.pass.cpp |  4 +++-
 .../input.streams/istream.unformatted/read.pass.cpp    |  4 +++-
 .../istream.unformatted/readsome.pass.cpp              |  4 +++-
 .../input.streams/istream.unformatted/seekg.pass.cpp   |  4 +++-
 .../istream.unformatted/seekg_off.pass.cpp             |  4 +++-
 .../input.streams/istream.unformatted/sync.pass.cpp    |  4 +++-
 .../input.streams/istream.unformatted/tellg.pass.cpp   |  4 +++-
 .../input.streams/istream.unformatted/unget.pass.cpp   |  4 +++-
 .../istream/istream.assign/member_swap.pass.cpp        |  4 +++-
 .../istream/istream.assign/move_assign.pass.cpp        |  4 +++-
 .../input.streams/istream/istream.cons/copy.fail.cpp   |  4 +++-
 .../input.streams/istream/istream.cons/move.pass.cpp   |  4 +++-
 .../istream/istream.cons/streambuf.pass.cpp            |  4 +++-
 .../input.streams/istream/istream_sentry/ctor.pass.cpp |  4 +++-
 .../input.streams/istream/types.pass.cpp               |  4 +++-
 .../iostream.format/nothing_to_do.pass.cpp             |  4 +++-
 .../output.streams/ostream.assign/member_swap.pass.cpp |  4 +++-
 .../output.streams/ostream.assign/move_assign.pass.cpp |  4 +++-
 .../output.streams/ostream.cons/move.pass.cpp          |  4 +++-
 .../output.streams/ostream.cons/streambuf.pass.cpp     |  4 +++-
 .../ostream.formatted/nothing_to_do.pass.cpp           |  4 +++-
 .../ostream.formatted.reqmts/tested_elsewhere.pass.cpp |  4 +++-
 .../ostream.inserters.arithmetic/bool.pass.cpp         |  4 +++-
 .../ostream.inserters.arithmetic/double.pass.cpp       |  4 +++-
 .../ostream.inserters.arithmetic/float.pass.cpp        |  4 +++-
 .../ostream.inserters.arithmetic/int.pass.cpp          |  4 +++-
 .../ostream.inserters.arithmetic/long.pass.cpp         |  4 +++-
 .../ostream.inserters.arithmetic/long_double.pass.cpp  |  4 +++-
 .../ostream.inserters.arithmetic/long_long.pass.cpp    |  4 +++-
 .../minmax_showbase.pass.cpp                           |  2 +-
 .../ostream.inserters.arithmetic/minus1.pass.cpp       |  4 +++-
 .../ostream.inserters.arithmetic/pointer.pass.cpp      |  4 +++-
 .../ostream.inserters.arithmetic/short.pass.cpp        |  4 +++-
 .../ostream.inserters.arithmetic/unsigned_int.pass.cpp |  4 +++-
 .../unsigned_long.pass.cpp                             |  4 +++-
 .../unsigned_long_long.pass.cpp                        |  4 +++-
 .../unsigned_short.pass.cpp                            |  4 +++-
 .../ostream.inserters.character/CharT.pass.cpp         |  4 +++-
 .../ostream.inserters.character/CharT_pointer.pass.cpp |  4 +++-
 .../ostream.inserters.character/char.pass.cpp          |  4 +++-
 .../ostream.inserters.character/char_pointer.pass.cpp  |  4 +++-
 .../ostream.inserters.character/char_to_wide.pass.cpp  |  4 +++-
 .../char_to_wide_pointer.pass.cpp                      |  4 +++-
 .../ostream.inserters.character/signed_char.pass.cpp   |  4 +++-
 .../signed_char_pointer.pass.cpp                       |  4 +++-
 .../ostream.inserters.character/unsigned_char.pass.cpp |  4 +++-
 .../unsigned_char_pointer.pass.cpp                     |  4 +++-
 .../ostream.inserters/basic_ios.pass.cpp               |  4 +++-
 .../ostream.inserters/ios_base.pass.cpp                |  4 +++-
 .../ostream.inserters/ostream.pass.cpp                 |  4 +++-
 .../ostream.inserters/streambuf.pass.cpp               |  4 +++-
 .../output.streams/ostream.manip/endl.pass.cpp         |  4 +++-
 .../output.streams/ostream.manip/ends.pass.cpp         |  4 +++-
 .../output.streams/ostream.manip/flush.pass.cpp        |  4 +++-
 .../ostream.rvalue/CharT_pointer.pass.cpp              |  4 +++-
 .../output.streams/ostream.seeks/seekp.pass.cpp        |  4 +++-
 .../output.streams/ostream.seeks/seekp2.pass.cpp       |  4 +++-
 .../output.streams/ostream.seeks/tellp.pass.cpp        |  4 +++-
 .../output.streams/ostream.unformatted/flush.pass.cpp  |  4 +++-
 .../output.streams/ostream.unformatted/put.pass.cpp    |  4 +++-
 .../output.streams/ostream.unformatted/write.pass.cpp  |  4 +++-
 .../output.streams/ostream/types.pass.cpp              |  4 +++-
 .../output.streams/ostream_sentry/construct.pass.cpp   |  4 +++-
 .../output.streams/ostream_sentry/destruct.pass.cpp    |  4 +++-
 .../iostream.format/quoted.manip/quoted.pass.cpp       | 10 +++++++---
 .../iostream.format/quoted.manip/quoted_char.fail.cpp  |  2 +-
 .../quoted.manip/quoted_traits.fail.cpp                |  2 +-
 .../iostream.format/std.manip/resetiosflags.pass.cpp   |  4 +++-
 .../iostream.format/std.manip/setbase.pass.cpp         |  4 +++-
 .../iostream.format/std.manip/setfill.pass.cpp         |  4 +++-
 .../iostream.format/std.manip/setiosflags.pass.cpp     |  4 +++-
 .../iostream.format/std.manip/setprecision.pass.cpp    |  4 +++-
 .../iostream.format/std.manip/setw.pass.cpp            |  4 +++-
 test/std/input.output/iostream.forward/iosfwd.pass.cpp |  4 +++-
 .../narrow.stream.objects/cerr.pass.cpp                |  4 +++-
 .../narrow.stream.objects/cin.pass.cpp                 |  4 +++-
 .../narrow.stream.objects/clog.pass.cpp                |  4 +++-
 .../narrow.stream.objects/cout.pass.cpp                |  4 +++-
 .../wide.stream.objects/wcerr.pass.cpp                 |  4 +++-
 .../iostream.objects/wide.stream.objects/wcin.pass.cpp |  4 +++-
 .../wide.stream.objects/wclog.pass.cpp                 |  4 +++-
 .../wide.stream.objects/wcout.pass.cpp                 |  4 +++-
 .../iostreams.base/fpos/fpos.members/state.pass.cpp    |  4 +++-
 .../fpos/fpos.operations/addition.pass.cpp             |  4 +++-
 .../fpos/fpos.operations/ctor_int.pass.cpp             |  4 +++-
 .../fpos/fpos.operations/difference.pass.cpp           |  4 +++-
 .../fpos/fpos.operations/eq_int.pass.cpp               |  4 +++-
 .../fpos/fpos.operations/offset.pass.cpp               |  4 +++-
 .../fpos/fpos.operations/streamsize.pass.cpp           |  4 +++-
 .../fpos/fpos.operations/subtraction.pass.cpp          |  4 +++-
 .../iostreams.base/fpos/nothing_to_do.pass.cpp         |  4 +++-
 .../ios.base/fmtflags.state/flags.pass.cpp             |  4 +++-
 .../ios.base/fmtflags.state/flags_fmtflags.pass.cpp    |  4 +++-
 .../ios.base/fmtflags.state/precision.pass.cpp         |  4 +++-
 .../fmtflags.state/precision_streamsize.pass.cpp       |  4 +++-
 .../ios.base/fmtflags.state/setf_fmtflags.pass.cpp     |  4 +++-
 .../fmtflags.state/setf_fmtflags_mask.pass.cpp         |  4 +++-
 .../ios.base/fmtflags.state/unsetf_mask.pass.cpp       |  4 +++-
 .../ios.base/fmtflags.state/width.pass.cpp             |  4 +++-
 .../ios.base/fmtflags.state/width_streamsize.pass.cpp  |  4 +++-
 .../ios.base.callback/register_callback.pass.cpp       |  4 +++-
 .../ios.base/ios.base.cons/dtor.pass.cpp               |  4 +++-
 .../ios.base/ios.base.locales/getloc.pass.cpp          |  4 +++-
 .../ios.base/ios.base.locales/imbue.pass.cpp           |  4 +++-
 .../ios.base/ios.base.storage/iword.pass.cpp           |  4 +++-
 .../ios.base/ios.base.storage/pword.pass.cpp           |  4 +++-
 .../ios.base/ios.base.storage/xalloc.pass.cpp          |  4 +++-
 .../ios.members.static/sync_with_stdio.pass.cpp        |  4 +++-
 .../ios.types/ios_Init/tested_elsewhere.pass.cpp       |  4 +++-
 .../ios_failure/ctor_char_pointer_error_code.pass.cpp  |  4 +++-
 .../ios_failure/ctor_string_error_code.pass.cpp        |  4 +++-
 .../ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp  |  4 +++-
 .../ios.base/ios.types/ios_iostate/iostate.pass.cpp    |  4 +++-
 .../ios.base/ios.types/ios_openmode/openmode.pass.cpp  |  4 +++-
 .../ios.base/ios.types/ios_seekdir/seekdir.pass.cpp    |  4 +++-
 .../ios.base/ios.types/nothing_to_do.pass.cpp          |  4 +++-
 .../iostreams.base/ios.base/nothing_to_do.pass.cpp     |  4 +++-
 .../ios/basic.ios.cons/ctor_streambuf.pass.cpp         |  4 +++-
 .../ios/basic.ios.members/copyfmt.pass.cpp             |  4 +++-
 .../iostreams.base/ios/basic.ios.members/fill.pass.cpp |  4 +++-
 .../ios/basic.ios.members/fill_char_type.pass.cpp      |  4 +++-
 .../ios/basic.ios.members/imbue.pass.cpp               |  4 +++-
 .../iostreams.base/ios/basic.ios.members/move.pass.cpp |  4 +++-
 .../ios/basic.ios.members/narrow.pass.cpp              |  4 +++-
 .../ios/basic.ios.members/rdbuf.pass.cpp               |  4 +++-
 .../ios/basic.ios.members/rdbuf_streambuf.pass.cpp     |  4 +++-
 .../ios/basic.ios.members/set_rdbuf.pass.cpp           |  4 +++-
 .../iostreams.base/ios/basic.ios.members/swap.pass.cpp |  4 +++-
 .../iostreams.base/ios/basic.ios.members/tie.pass.cpp  |  4 +++-
 .../ios/basic.ios.members/tie_ostream.pass.cpp         |  4 +++-
 .../ios/basic.ios.members/widen.pass.cpp               |  4 +++-
 .../iostreams.base/ios/iostate.flags/bad.pass.cpp      |  4 +++-
 .../iostreams.base/ios/iostate.flags/bool.pass.cpp     |  4 +++-
 .../iostreams.base/ios/iostate.flags/clear.pass.cpp    |  4 +++-
 .../iostreams.base/ios/iostate.flags/eof.pass.cpp      |  4 +++-
 .../ios/iostate.flags/exceptions.pass.cpp              |  4 +++-
 .../ios/iostate.flags/exceptions_iostate.pass.cpp      |  4 +++-
 .../iostreams.base/ios/iostate.flags/fail.pass.cpp     |  4 +++-
 .../iostreams.base/ios/iostate.flags/good.pass.cpp     |  4 +++-
 .../iostreams.base/ios/iostate.flags/not.pass.cpp      |  4 +++-
 .../iostreams.base/ios/iostate.flags/rdstate.pass.cpp  |  4 +++-
 .../iostreams.base/ios/iostate.flags/setstate.pass.cpp |  4 +++-
 .../std/input.output/iostreams.base/ios/types.pass.cpp |  4 +++-
 .../iostreams.base/is_error_code_enum_io_errc.pass.cpp |  4 +++-
 .../std.ios.manip/adjustfield.manip/internal.pass.cpp  |  4 +++-
 .../std.ios.manip/adjustfield.manip/left.pass.cpp      |  4 +++-
 .../std.ios.manip/adjustfield.manip/right.pass.cpp     |  4 +++-
 .../std.ios.manip/basefield.manip/dec.pass.cpp         |  4 +++-
 .../std.ios.manip/basefield.manip/hex.pass.cpp         |  4 +++-
 .../std.ios.manip/basefield.manip/oct.pass.cpp         |  4 +++-
 .../error.reporting/iostream_category.pass.cpp         |  4 +++-
 .../error.reporting/make_error_code.pass.cpp           |  4 +++-
 .../error.reporting/make_error_condition.pass.cpp      |  4 +++-
 .../floatfield.manip/defaultfloat.pass.cpp             |  4 +++-
 .../std.ios.manip/floatfield.manip/fixed.pass.cpp      |  4 +++-
 .../std.ios.manip/floatfield.manip/hexfloat.pass.cpp   |  4 +++-
 .../std.ios.manip/floatfield.manip/scientific.pass.cpp |  4 +++-
 .../std.ios.manip/fmtflags.manip/boolalpha.pass.cpp    |  4 +++-
 .../std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp  |  4 +++-
 .../std.ios.manip/fmtflags.manip/noshowbase.pass.cpp   |  4 +++-
 .../std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp  |  4 +++-
 .../std.ios.manip/fmtflags.manip/noshowpos.pass.cpp    |  4 +++-
 .../std.ios.manip/fmtflags.manip/noskipws.pass.cpp     |  4 +++-
 .../std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp    |  4 +++-
 .../std.ios.manip/fmtflags.manip/nouppercase.pass.cpp  |  4 +++-
 .../std.ios.manip/fmtflags.manip/showbase.pass.cpp     |  4 +++-
 .../std.ios.manip/fmtflags.manip/showpoint.pass.cpp    |  4 +++-
 .../std.ios.manip/fmtflags.manip/showpos.pass.cpp      |  4 +++-
 .../std.ios.manip/fmtflags.manip/skipws.pass.cpp       |  4 +++-
 .../std.ios.manip/fmtflags.manip/unitbuf.pass.cpp      |  4 +++-
 .../std.ios.manip/fmtflags.manip/uppercase.pass.cpp    |  4 +++-
 .../std.ios.manip/nothing_to_do.pass.cpp               |  4 +++-
 .../iostreams.base/stream.types/streamoff.pass.cpp     |  4 +++-
 .../iostreams.base/stream.types/streamsize.pass.cpp    |  4 +++-
 .../iostream.limits.imbue/tested_elsewhere.pass.cpp    |  4 +++-
 .../iostreams.limits.pos/nothing_to_do.pass.cpp        |  4 +++-
 .../iostreams.threadsafety/nothing_to_do.pass.cpp      |  4 +++-
 .../iostreams.requirements/nothing_to_do.pass.cpp      |  4 +++-
 test/std/input.output/nothing_to_do.pass.cpp           |  4 +++-
 .../streambuf.reqts/tested_elsewhere.pass.cpp          |  4 +++-
 .../streambuf/streambuf.cons/copy.fail.cpp             |  4 +++-
 .../streambuf/streambuf.cons/copy.pass.cpp             |  4 +++-
 .../streambuf/streambuf.cons/default.fail.cpp          |  4 +++-
 .../streambuf/streambuf.cons/default.pass.cpp          |  4 +++-
 .../streambuf/streambuf.members/nothing_to_do.pass.cpp |  4 +++-
 .../streambuf.buffer/pubseekoff.pass.cpp               |  4 +++-
 .../streambuf.buffer/pubseekpos.pass.cpp               |  4 +++-
 .../streambuf.buffer/pubsetbuf.pass.cpp                |  4 +++-
 .../streambuf.buffer/pubsync.pass.cpp                  |  4 +++-
 .../streambuf.locales/locales.pass.cpp                 |  4 +++-
 .../streambuf.pub.get/in_avail.pass.cpp                |  4 +++-
 .../streambuf.pub.get/sbumpc.pass.cpp                  |  4 +++-
 .../streambuf.members/streambuf.pub.get/sgetc.pass.cpp |  4 +++-
 .../streambuf.members/streambuf.pub.get/sgetn.pass.cpp |  4 +++-
 .../streambuf.pub.get/snextc.pass.cpp                  |  4 +++-
 .../streambuf.pub.pback/sputbackc.pass.cpp             |  4 +++-
 .../streambuf.pub.pback/sungetc.pass.cpp               |  4 +++-
 .../streambuf.members/streambuf.pub.put/sputc.pass.cpp |  4 +++-
 .../streambuf.members/streambuf.pub.put/sputn.pass.cpp |  4 +++-
 .../streambuf.protected/nothing_to_do.pass.cpp         |  4 +++-
 .../streambuf.assign/assign.pass.cpp                   |  4 +++-
 .../streambuf.protected/streambuf.assign/swap.pass.cpp |  4 +++-
 .../streambuf.get.area/gbump.pass.cpp                  |  4 +++-
 .../streambuf.get.area/setg.pass.cpp                   |  4 +++-
 .../streambuf.put.area/pbump.pass.cpp                  |  4 +++-
 .../streambuf.put.area/pbump2gig.pass.cpp              |  4 +++-
 .../streambuf.put.area/setp.pass.cpp                   |  4 +++-
 .../streambuf.virtuals/nothing_to_do.pass.cpp          |  4 +++-
 .../streambuf.virt.buffer/tested_elsewhere.pass.cpp    |  4 +++-
 .../streambuf.virt.get/showmanyc.pass.cpp              |  4 +++-
 .../streambuf.virt.get/uflow.pass.cpp                  |  4 +++-
 .../streambuf.virt.get/underflow.pass.cpp              |  4 +++-
 .../streambuf.virt.get/xsgetn.pass.cpp                 |  4 +++-
 .../streambuf.virt.locales/nothing_to_do.pass.cpp      |  4 +++-
 .../streambuf.virt.pback/pbackfail.pass.cpp            |  4 +++-
 .../streambuf.virt.put/overflow.pass.cpp               |  4 +++-
 .../streambuf.virt.put/xsputn.pass.cpp                 |  4 +++-
 .../stream.buffers/streambuf/types.pass.cpp            |  4 +++-
 .../istringstream.assign/member_swap.pass.cpp          |  4 +++-
 .../istringstream/istringstream.assign/move.pass.cpp   |  4 +++-
 .../istringstream.assign/nonmember_swap.pass.cpp       |  4 +++-
 .../istringstream/istringstream.cons/default.pass.cpp  |  4 +++-
 .../istringstream/istringstream.cons/move.pass.cpp     |  4 +++-
 .../istringstream/istringstream.cons/string.pass.cpp   |  4 +++-
 .../istringstream/istringstream.members/str.pass.cpp   |  4 +++-
 .../string.streams/istringstream/types.pass.cpp        |  4 +++-
 .../ostringstream.assign/member_swap.pass.cpp          |  4 +++-
 .../ostringstream/ostringstream.assign/move.pass.cpp   |  4 +++-
 .../ostringstream.assign/nonmember_swap.pass.cpp       |  4 +++-
 .../ostringstream/ostringstream.cons/default.pass.cpp  |  4 +++-
 .../ostringstream/ostringstream.cons/move.pass.cpp     |  4 +++-
 .../ostringstream/ostringstream.cons/string.pass.cpp   |  4 +++-
 .../ostringstream/ostringstream.members/str.pass.cpp   |  4 +++-
 .../string.streams/ostringstream/types.pass.cpp        |  4 +++-
 .../stringbuf/stringbuf.assign/member_swap.pass.cpp    |  4 +++-
 .../stringbuf/stringbuf.assign/move.pass.cpp           |  4 +++-
 .../stringbuf/stringbuf.assign/nonmember_swap.pass.cpp |  4 +++-
 .../stringbuf/stringbuf.cons/default.pass.cpp          |  4 +++-
 .../stringbuf/stringbuf.cons/move.pass.cpp             |  4 +++-
 .../stringbuf/stringbuf.cons/string.pass.cpp           |  4 +++-
 .../stringbuf/stringbuf.members/str.pass.cpp           |  4 +++-
 .../stringbuf/stringbuf.virtuals/overflow.pass.cpp     |  4 +++-
 .../stringbuf/stringbuf.virtuals/pbackfail.pass.cpp    |  4 +++-
 .../stringbuf/stringbuf.virtuals/seekoff.pass.cpp      |  4 +++-
 .../stringbuf/stringbuf.virtuals/seekpos.pass.cpp      |  4 +++-
 .../stringbuf/stringbuf.virtuals/setbuf.pass.cpp       |  4 +++-
 .../stringbuf/stringbuf.virtuals/underflow.pass.cpp    |  4 +++-
 .../string.streams/stringbuf/types.pass.cpp            |  4 +++-
 .../string.streams/stringstream.cons/default.pass.cpp  |  4 +++-
 .../string.streams/stringstream.cons/move.pass.cpp     |  4 +++-
 .../string.streams/stringstream.cons/move2.pass.cpp    |  4 +++-
 .../string.streams/stringstream.cons/string.pass.cpp   |  4 +++-
 .../stringstream.assign/member_swap.pass.cpp           |  4 +++-
 .../stringstream.assign/move.pass.cpp                  |  4 +++-
 .../stringstream.assign/nonmember_swap.pass.cpp        |  4 +++-
 .../string.streams/stringstream.members/str.pass.cpp   |  4 +++-
 .../string.streams/stringstream/types.pass.cpp         |  4 +++-
 test/std/iterators/iterator.container/data.pass.cpp    |  4 +++-
 .../iterators/iterator.container/empty.array.fail.cpp  |  4 +++-
 .../iterator.container/empty.container.fail.cpp        |  4 +++-
 .../iterator.container/empty.initializer_list.fail.cpp |  4 +++-
 test/std/iterators/iterator.container/empty.pass.cpp   |  4 +++-
 test/std/iterators/iterator.container/size.pass.cpp    |  4 +++-
 .../iterator.basic/iterator.pass.cpp                   |  4 +++-
 .../iterator.operations/advance.pass.cpp               |  4 +++-
 .../iterator.operations/distance.pass.cpp              |  4 +++-
 .../iterator.operations/next.pass.cpp                  |  4 +++-
 .../iterator.operations/prev.pass.cpp                  |  4 +++-
 .../iterator.traits/const_pointer.pass.cpp             |  4 +++-
 .../iterator.traits/const_volatile_pointer.pass.cpp    |  4 +++-
 .../iterator.primitives/iterator.traits/empty.fail.cpp |  4 +++-
 .../iterator.primitives/iterator.traits/empty.pass.cpp |  4 +++-
 .../iterator.traits/iterator.pass.cpp                  |  4 +++-
 .../iterator.traits/pointer.pass.cpp                   |  4 +++-
 .../iterator.traits/volatile_pointer.pass.cpp          |  4 +++-
 .../iterator.primitives/nothing_to_do.pass.cpp         |  4 +++-
 .../bidirectional_iterator_tag.pass.cpp                |  4 +++-
 .../std.iterator.tags/forward_iterator_tag.pass.cpp    |  4 +++-
 .../std.iterator.tags/input_iterator_tag.pass.cpp      |  4 +++-
 .../std.iterator.tags/output_iterator_tag.pass.cpp     |  4 +++-
 .../random_access_iterator_tag.pass.cpp                |  4 +++-
 test/std/iterators/iterator.range/begin-end.fail.cpp   |  4 +++-
 test/std/iterators/iterator.range/begin-end.pass.cpp   |  4 +++-
 .../bidirectional.iterators/nothing_to_do.pass.cpp     |  4 +++-
 .../forward.iterators/nothing_to_do.pass.cpp           |  4 +++-
 .../input.iterators/nothing_to_do.pass.cpp             |  4 +++-
 .../iterator.iterators/nothing_to_do.pass.cpp          |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../iterator.requirements/nothing_to_do.pass.cpp       |  4 +++-
 .../output.iterators/nothing_to_do.pass.cpp            |  4 +++-
 .../random.access.iterators/nothing_to_do.pass.cpp     |  4 +++-
 .../iterators/iterator.synopsis/nothing_to_do.pass.cpp |  4 +++-
 .../iterators.general/gcc_workaround.pass.cpp          |  4 +++-
 .../iterators/iterators.general/nothing_to_do.pass.cpp |  4 +++-
 .../back.insert.iter.cons/container.fail.cpp           |  4 +++-
 .../back.insert.iter.cons/container.pass.cpp           |  4 +++-
 .../back.insert.iter.op++/post.pass.cpp                |  4 +++-
 .../back.insert.iter.op++/pre.pass.cpp                 |  4 +++-
 .../back.insert.iter.op=/lv_value.pass.cpp             |  4 +++-
 .../back.insert.iter.op=/rv_value.pass.cpp             |  4 +++-
 .../back.insert.iter.op_astrk/test.pass.cpp            |  4 +++-
 .../back.insert.iter.ops/back.inserter/test.pass.cpp   |  4 +++-
 .../back.insert.iter.ops/nothing_to_do.pass.cpp        |  4 +++-
 .../back.insert.iterator/types.pass.cpp                |  4 +++-
 .../front.insert.iter.cons/container.fail.cpp          |  4 +++-
 .../front.insert.iter.cons/container.pass.cpp          |  4 +++-
 .../front.insert.iter.op++/post.pass.cpp               |  4 +++-
 .../front.insert.iter.op++/pre.pass.cpp                |  4 +++-
 .../front.insert.iter.op=/lv_value.pass.cpp            |  4 +++-
 .../front.insert.iter.op=/rv_value.pass.cpp            |  4 +++-
 .../front.insert.iter.op_astrk/test.pass.cpp           |  4 +++-
 .../front.insert.iter.ops/front.inserter/test.pass.cpp |  4 +++-
 .../front.insert.iter.ops/nothing_to_do.pass.cpp       |  4 +++-
 .../front.insert.iterator/types.pass.cpp               |  4 +++-
 .../insert.iter.ops/insert.iter.cons/test.pass.cpp     |  4 +++-
 .../insert.iter.ops/insert.iter.op++/post.pass.cpp     |  4 +++-
 .../insert.iter.ops/insert.iter.op++/pre.pass.cpp      |  4 +++-
 .../insert.iter.ops/insert.iter.op=/lv_value.pass.cpp  |  4 +++-
 .../insert.iter.ops/insert.iter.op=/rv_value.pass.cpp  |  4 +++-
 .../insert.iter.ops/insert.iter.op_astrk/test.pass.cpp |  4 +++-
 .../insert.iter.ops/inserter/test.pass.cpp             |  4 +++-
 .../insert.iter.ops/nothing_to_do.pass.cpp             |  4 +++-
 .../insert.iterators/insert.iterator/types.pass.cpp    |  4 +++-
 .../insert.iterators/nothing_to_do.pass.cpp            |  4 +++-
 .../move.iter.nonmember/make_move_iterator.pass.cpp    |  4 +++-
 .../move.iter.ops/move.iter.nonmember/minus.pass.cpp   |  4 +++-
 .../move.iter.ops/move.iter.nonmember/plus.pass.cpp    |  4 +++-
 .../move.iter.op.+/difference_type.pass.cpp            |  4 +++-
 .../move.iter.op.+=/difference_type.pass.cpp           |  4 +++-
 .../move.iter.op.-/difference_type.pass.cpp            |  4 +++-
 .../move.iter.op.-=/difference_type.pass.cpp           |  4 +++-
 .../move.iter.ops/move.iter.op.comp/op_eq.pass.cpp     |  4 +++-
 .../move.iter.ops/move.iter.op.comp/op_gt.pass.cpp     |  4 +++-
 .../move.iter.ops/move.iter.op.comp/op_gte.pass.cpp    |  4 +++-
 .../move.iter.ops/move.iter.op.comp/op_lt.pass.cpp     |  4 +++-
 .../move.iter.ops/move.iter.op.comp/op_lte.pass.cpp    |  4 +++-
 .../move.iter.ops/move.iter.op.comp/op_neq.pass.cpp    |  4 +++-
 .../move.iter.ops/move.iter.op.const/convert.fail.cpp  |  4 +++-
 .../move.iter.ops/move.iter.op.const/convert.pass.cpp  |  4 +++-
 .../move.iter.ops/move.iter.op.const/default.pass.cpp  |  4 +++-
 .../move.iter.ops/move.iter.op.const/iter.fail.cpp     |  4 +++-
 .../move.iter.ops/move.iter.op.const/iter.pass.cpp     |  4 +++-
 .../move.iter.op.conv/tested_elsewhere.pass.cpp        |  4 +++-
 .../move.iter.ops/move.iter.op.decr/post.pass.cpp      |  4 +++-
 .../move.iter.ops/move.iter.op.decr/pre.pass.cpp       |  4 +++-
 .../move.iter.ops/move.iter.op.incr/post.pass.cpp      |  4 +++-
 .../move.iter.ops/move.iter.op.incr/pre.pass.cpp       |  4 +++-
 .../move.iter.op.index/difference_type.pass.cpp        |  4 +++-
 .../move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp   |  4 +++-
 .../move.iter.ops/move.iter.op.star/op_star.pass.cpp   |  4 +++-
 .../move.iter.ops/move.iter.op=/move_iterator.fail.cpp |  4 +++-
 .../move.iter.ops/move.iter.op=/move_iterator.pass.cpp |  4 +++-
 .../move.iter.ops/nothing_to_do.pass.cpp               |  4 +++-
 .../move.iter.requirements/nothing_to_do.pass.cpp      |  4 +++-
 .../move.iterators/move.iterator/types.pass.cpp        |  4 +++-
 .../move.iterators/nothing_to_do.pass.cpp              |  4 +++-
 .../iterators/predef.iterators/nothing_to_do.pass.cpp  |  4 +++-
 .../reverse.iterators/nothing_to_do.pass.cpp           |  4 +++-
 .../reverse.iter.ops/nothing_to_do.pass.cpp            |  4 +++-
 .../reverse.iter.cons/default.pass.cpp                 |  4 +++-
 .../reverse.iter.ops/reverse.iter.cons/iter.fail.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.cons/iter.pass.cpp   |  4 +++-
 .../reverse.iter.cons/reverse_iterator.fail.cpp        |  4 +++-
 .../reverse.iter.cons/reverse_iterator.pass.cpp        |  4 +++-
 .../reverse.iter.conv/tested_elsewhere.pass.cpp        |  4 +++-
 .../reverse.iter.make/make_reverse_iterator.pass.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.op!=/test.pass.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.op++/post.pass.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.op++/pre.pass.cpp    |  4 +++-
 .../reverse.iter.op+/difference_type.pass.cpp          |  4 +++-
 .../reverse.iter.op+=/difference_type.pass.cpp         |  4 +++-
 .../reverse.iter.ops/reverse.iter.op--/post.pass.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.op--/pre.pass.cpp    |  4 +++-
 .../reverse.iter.op-/difference_type.pass.cpp          |  4 +++-
 .../reverse.iter.op-=/difference_type.pass.cpp         |  4 +++-
 .../reverse.iter.op.star/op_star.pass.cpp              |  4 +++-
 .../reverse.iter.op=/reverse_iterator.fail.cpp         |  4 +++-
 .../reverse.iter.op=/reverse_iterator.pass.cpp         |  4 +++-
 .../reverse.iter.ops/reverse.iter.op==/test.pass.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp |  4 +++-
 .../reverse.iter.ops/reverse.iter.opgt/test.pass.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp  |  4 +++-
 .../reverse.iter.opindex/difference_type.pass.cpp      |  4 +++-
 .../reverse.iter.ops/reverse.iter.oplt/test.pass.cpp   |  4 +++-
 .../reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp  |  4 +++-
 .../reverse.iter.opref/op_arrow.pass.cpp               |  4 +++-
 .../reverse.iter.opsum/difference_type.pass.cpp        |  4 +++-
 .../reverse.iter.requirements/nothing_to_do.pass.cpp   |  4 +++-
 .../reverse.iterators/reverse.iterator/types.pass.cpp  |  4 +++-
 .../istream.iterator.cons/copy.pass.cpp                |  4 +++-
 .../istream.iterator.cons/default.fail.cpp             |  4 +++-
 .../istream.iterator.cons/default.pass.cpp             |  4 +++-
 .../istream.iterator.cons/istream.pass.cpp             |  4 +++-
 .../istream.iterator.ops/arrow.pass.cpp                |  4 +++-
 .../istream.iterator.ops/dereference.pass.cpp          |  4 +++-
 .../istream.iterator.ops/equal.pass.cpp                |  4 +++-
 .../istream.iterator.ops/post_increment.pass.cpp       |  4 +++-
 .../istream.iterator.ops/pre_increment.pass.cpp        |  4 +++-
 .../stream.iterators/istream.iterator/types.pass.cpp   |  4 +++-
 .../istreambuf.iterator.cons/default.pass.cpp          |  4 +++-
 .../istreambuf.iterator.cons/istream.pass.cpp          |  4 +++-
 .../istreambuf.iterator.cons/proxy.pass.cpp            |  4 +++-
 .../istreambuf.iterator.cons/streambuf.pass.cpp        |  4 +++-
 .../istreambuf.iterator_equal/equal.pass.cpp           |  4 +++-
 .../istreambuf.iterator_op!=/not_equal.pass.cpp        |  4 +++-
 .../istreambuf.iterator_op++/dereference.pass.cpp      |  4 +++-
 .../istreambuf.iterator_op==/equal.pass.cpp            |  4 +++-
 .../post_increment.pass.cpp                            |  4 +++-
 .../pre_increment.pass.cpp                             |  4 +++-
 .../istreambuf.iterator_proxy/proxy.pass.cpp           |  4 +++-
 .../istreambuf.iterator/types.pass.cpp                 |  4 +++-
 .../iterator.range/begin_array.pass.cpp                |  4 +++-
 .../iterator.range/begin_const.pass.cpp                |  4 +++-
 .../iterator.range/begin_non_const.pass.cpp            |  4 +++-
 .../stream.iterators/iterator.range/end_array.pass.cpp |  4 +++-
 .../stream.iterators/iterator.range/end_const.pass.cpp |  4 +++-
 .../iterator.range/end_non_const.pass.cpp              |  4 +++-
 .../iterators/stream.iterators/nothing_to_do.pass.cpp  |  4 +++-
 .../ostream.iterator.cons.des/copy.pass.cpp            |  4 +++-
 .../ostream.iterator.cons.des/ostream.pass.cpp         |  4 +++-
 .../ostream.iterator.cons.des/ostream_delim.pass.cpp   |  4 +++-
 .../ostream.iterator.ops/assign_t.pass.cpp             |  4 +++-
 .../ostream.iterator.ops/dereference.pass.cpp          |  4 +++-
 .../ostream.iterator.ops/increment.pass.cpp            |  4 +++-
 .../stream.iterators/ostream.iterator/types.pass.cpp   |  4 +++-
 .../ostreambuf.iter.cons/ostream.pass.cpp              |  4 +++-
 .../ostreambuf.iter.cons/streambuf.pass.cpp            |  4 +++-
 .../ostreambuf.iter.ops/assign_c.pass.cpp              |  4 +++-
 .../ostreambuf.iter.ops/deref.pass.cpp                 |  4 +++-
 .../ostreambuf.iter.ops/failed.pass.cpp                |  4 +++-
 .../ostreambuf.iter.ops/increment.pass.cpp             |  4 +++-
 .../ostreambuf.iterator/types.pass.cpp                 |  4 +++-
 .../cmp/cmp.common/common_comparison_category.pass.cpp |  4 +++-
 .../cmp/cmp.partialord/partialord.pass.cpp             |  4 +++-
 .../cmp/cmp.strongeq/cmp.strongeq.pass.cpp             |  4 +++-
 .../cmp/cmp.strongord/strongord.pass.cpp               |  4 +++-
 .../cmp/cmp.weakeq/cmp.weakeq.pass.cpp                 |  4 +++-
 .../language.support/cmp/cmp.weakord/weakord.pass.cpp  |  4 +++-
 .../cstdint/cstdint.syn/cstdint.pass.cpp               |  4 +++-
 test/std/language.support/nothing_to_do.pass.cpp       |  4 +++-
 .../support.dynamic/align_val_t.pass.cpp               |  4 +++-
 .../alloc.errors/bad.alloc/bad_alloc.pass.cpp          |  4 +++-
 .../new.badlength/bad_array_new_length.pass.cpp        |  4 +++-
 .../alloc.errors/new.handler/new_handler.pass.cpp      |  4 +++-
 .../alloc.errors/nothing_to_do.pass.cpp                |  4 +++-
 .../set.new.handler/get_new_handler.pass.cpp           |  4 +++-
 .../set.new.handler/set_new_handler.pass.cpp           |  4 +++-
 .../delete_align_val_t_replace.pass.cpp                |  4 +++-
 .../new.delete.array/new_align_val_t.pass.cpp          |  4 +++-
 .../new.delete.array/new_align_val_t_nothrow.pass.cpp  |  4 +++-
 .../new_align_val_t_nothrow_replace.pass.cpp           |  4 +++-
 .../new.delete.array/new_align_val_t_replace.pass.cpp  |  4 +++-
 .../new.delete/new.delete.array/new_array.pass.cpp     |  4 +++-
 .../new.delete.array/new_array_nothrow.pass.cpp        |  4 +++-
 .../new_array_nothrow_replace.pass.cpp                 |  4 +++-
 .../new.delete.array/new_array_replace.pass.cpp        |  4 +++-
 .../new.delete/new.delete.array/new_size.sh.cpp        |  4 +++-
 .../new.delete/new.delete.array/new_size_align.sh.cpp  |  4 +++-
 .../new.delete.array/new_size_align_nothrow.sh.cpp     |  4 +++-
 .../new.delete.array/new_size_nothrow.sh.cpp           |  4 +++-
 .../new.delete.array/sized_delete_array11.pass.cpp     |  4 +++-
 .../new.delete.array/sized_delete_array14.pass.cpp     |  4 +++-
 ...ed_delete_array_calls_unsized_delete_array.pass.cpp |  4 +++-
 .../sized_delete_array_fsizeddeallocation.sh.cpp       |  4 +++-
 .../new.delete.dataraces/not_testable.pass.cpp         |  4 +++-
 .../new.delete/new.delete.placement/new.pass.cpp       |  4 +++-
 .../new.delete/new.delete.placement/new_array.pass.cpp |  4 +++-
 .../new.delete.placement/new_array_ptr.fail.cpp        |  4 +++-
 .../new.delete/new.delete.placement/new_ptr.fail.cpp   |  4 +++-
 .../delete_align_val_t_replace.pass.cpp                |  4 +++-
 .../new.delete/new.delete.single/new.pass.cpp          |  4 +++-
 .../new.delete.single/new_align_val_t.pass.cpp         |  4 +++-
 .../new.delete.single/new_align_val_t_nothrow.pass.cpp |  4 +++-
 .../new_align_val_t_nothrow_replace.pass.cpp           |  4 +++-
 .../new.delete.single/new_align_val_t_replace.pass.cpp |  4 +++-
 .../new.delete/new.delete.single/new_nothrow.pass.cpp  |  4 +++-
 .../new.delete.single/new_nothrow_replace.pass.cpp     |  4 +++-
 .../new.delete/new.delete.single/new_replace.pass.cpp  |  4 +++-
 .../new.delete/new.delete.single/new_size.fail.cpp     |  4 +++-
 .../new.delete/new.delete.single/new_size_align.sh.cpp |  4 +++-
 .../new.delete.single/new_size_align_nothrow.sh.cpp    |  4 +++-
 .../new.delete.single/new_size_nothrow.fail.cpp        |  4 +++-
 .../new.delete.single/sized_delete11.pass.cpp          |  4 +++-
 .../new.delete.single/sized_delete14.pass.cpp          |  4 +++-
 .../sized_delete_calls_unsized_delete.pass.cpp         |  4 +++-
 .../sized_delete_fsizeddeallocation.sh.cpp             |  4 +++-
 .../support.dynamic/new.delete/nothing_to_do.pass.cpp  |  4 +++-
 .../ptr.launder/launder.nodiscard.fail.cpp             |  4 +++-
 .../support.dynamic/ptr.launder/launder.pass.cpp       |  4 +++-
 .../support.dynamic/ptr.launder/launder.types.fail.cpp |  4 +++-
 .../bad.exception/bad_exception.pass.cpp               |  4 +++-
 .../support.exception/except.nested/assign.pass.cpp    |  4 +++-
 .../support.exception/except.nested/ctor_copy.pass.cpp |  4 +++-
 .../except.nested/ctor_default.pass.cpp                |  4 +++-
 .../except.nested/rethrow_if_nested.pass.cpp           |  4 +++-
 .../except.nested/rethrow_nested.pass.cpp              |  4 +++-
 .../except.nested/throw_with_nested.pass.cpp           |  4 +++-
 .../exception.terminate/nothing_to_do.pass.cpp         |  4 +++-
 .../set.terminate/get_terminate.pass.cpp               |  4 +++-
 .../set.terminate/set_terminate.pass.cpp               |  4 +++-
 .../terminate.handler/terminate_handler.pass.cpp       |  4 +++-
 .../exception.terminate/terminate/terminate.pass.cpp   |  4 +++-
 .../support.exception/exception/exception.pass.cpp     |  4 +++-
 .../propagation/current_exception.pass.cpp             |  4 +++-
 .../propagation/exception_ptr.pass.cpp                 |  4 +++-
 .../propagation/make_exception_ptr.pass.cpp            |  4 +++-
 .../propagation/rethrow_exception.pass.cpp             |  4 +++-
 .../uncaught/uncaught_exception.pass.cpp               |  4 +++-
 .../uncaught/uncaught_exceptions.pass.cpp              |  4 +++-
 .../support.general/nothing_to_do.pass.cpp             |  4 +++-
 .../support.initlist/include_cxx03.pass.cpp            |  4 +++-
 .../support.initlist.access/access.pass.cpp            |  4 +++-
 .../support.initlist.cons/default.pass.cpp             |  4 +++-
 .../support.initlist.range/begin_end.pass.cpp          |  4 +++-
 .../language.support/support.initlist/types.pass.cpp   |  4 +++-
 .../support.limits/c.limits/cfloat.pass.cpp            |  4 +++-
 .../support.limits/c.limits/climits.pass.cpp           |  4 +++-
 .../limits/denorm.style/check_values.pass.cpp          |  4 +++-
 .../support.limits/limits/is_specialized.pass.cpp      |  4 +++-
 .../numeric.limits.members/const_data_members.pass.cpp |  4 +++-
 .../limits/numeric.limits.members/denorm_min.pass.cpp  |  4 +++-
 .../limits/numeric.limits.members/digits.pass.cpp      |  4 +++-
 .../limits/numeric.limits.members/digits10.pass.cpp    |  4 +++-
 .../limits/numeric.limits.members/epsilon.pass.cpp     |  4 +++-
 .../limits/numeric.limits.members/has_denorm.pass.cpp  |  4 +++-
 .../numeric.limits.members/has_denorm_loss.pass.cpp    |  4 +++-
 .../numeric.limits.members/has_infinity.pass.cpp       |  4 +++-
 .../numeric.limits.members/has_quiet_NaN.pass.cpp      |  4 +++-
 .../numeric.limits.members/has_signaling_NaN.pass.cpp  |  4 +++-
 .../limits/numeric.limits.members/infinity.pass.cpp    |  4 +++-
 .../limits/numeric.limits.members/is_bounded.pass.cpp  |  4 +++-
 .../limits/numeric.limits.members/is_exact.pass.cpp    |  4 +++-
 .../limits/numeric.limits.members/is_iec559.pass.cpp   |  4 +++-
 .../limits/numeric.limits.members/is_integer.pass.cpp  |  4 +++-
 .../limits/numeric.limits.members/is_modulo.pass.cpp   |  4 +++-
 .../limits/numeric.limits.members/is_signed.pass.cpp   |  4 +++-
 .../limits/numeric.limits.members/lowest.pass.cpp      |  4 +++-
 .../limits/numeric.limits.members/max.pass.cpp         |  4 +++-
 .../numeric.limits.members/max_digits10.pass.cpp       |  4 +++-
 .../numeric.limits.members/max_exponent.pass.cpp       |  4 +++-
 .../numeric.limits.members/max_exponent10.pass.cpp     |  4 +++-
 .../limits/numeric.limits.members/min.pass.cpp         |  4 +++-
 .../numeric.limits.members/min_exponent.pass.cpp       |  4 +++-
 .../numeric.limits.members/min_exponent10.pass.cpp     |  4 +++-
 .../limits/numeric.limits.members/quiet_NaN.pass.cpp   |  4 +++-
 .../limits/numeric.limits.members/radix.pass.cpp       |  4 +++-
 .../limits/numeric.limits.members/round_error.pass.cpp |  4 +++-
 .../limits/numeric.limits.members/round_style.pass.cpp |  4 +++-
 .../numeric.limits.members/signaling_NaN.pass.cpp      |  4 +++-
 .../numeric.limits.members/tinyness_before.pass.cpp    |  4 +++-
 .../limits/numeric.limits.members/traps.pass.cpp       |  4 +++-
 .../limits/numeric.limits/default.pass.cpp             |  4 +++-
 .../limits/numeric.special/nothing_to_do.pass.cpp      |  4 +++-
 .../limits/round.style/check_values.pass.cpp           |  4 +++-
 .../support.limits/nothing_to_do.pass.cpp              |  4 +++-
 .../support.limits.general/algorithm.version.pass.cpp  |  2 +-
 .../support.limits.general/any.version.pass.cpp        |  2 +-
 .../support.limits.general/array.version.pass.cpp      |  2 +-
 .../support.limits.general/atomic.version.pass.cpp     |  2 +-
 .../support.limits.general/bit.version.pass.cpp        |  2 +-
 .../support.limits.general/charconv.pass.cpp           |  4 +++-
 .../support.limits.general/chrono.version.pass.cpp     |  2 +-
 .../support.limits.general/cmath.version.pass.cpp      |  2 +-
 .../support.limits.general/compare.version.pass.cpp    |  2 +-
 .../support.limits.general/complex.version.pass.cpp    |  2 +-
 .../support.limits.general/concepts.version.pass.cpp   |  4 +++-
 .../support.limits.general/cstddef.version.pass.cpp    |  2 +-
 .../support.limits.general/deque.version.pass.cpp      |  2 +-
 .../support.limits.general/exception.version.pass.cpp  |  2 +-
 .../support.limits.general/execution.version.pass.cpp  |  4 +++-
 .../support.limits.general/filesystem.version.pass.cpp |  2 +-
 .../forward_list.version.pass.cpp                      |  2 +-
 .../support.limits.general/functional.version.pass.cpp |  2 +-
 .../support.limits.general/iomanip.version.pass.cpp    |  2 +-
 .../support.limits.general/istream.version.pass.cpp    |  2 +-
 .../support.limits.general/iterator.version.pass.cpp   |  2 +-
 .../support.limits.general/limits.version.pass.cpp     |  2 +-
 .../support.limits.general/list.version.pass.cpp       |  2 +-
 .../support.limits.general/locale.version.pass.cpp     |  2 +-
 .../support.limits.general/map.version.pass.cpp        |  2 +-
 .../support.limits.general/memory.version.pass.cpp     |  2 +-
 .../memory_resource.version.pass.cpp                   |  4 +++-
 .../support.limits.general/mutex.version.pass.cpp      |  2 +-
 .../support.limits.general/new.version.pass.cpp        |  2 +-
 .../support.limits.general/numeric.version.pass.cpp    |  2 +-
 .../support.limits.general/optional.version.pass.cpp   |  2 +-
 .../support.limits.general/ostream.version.pass.cpp    |  2 +-
 .../support.limits.general/regex.version.pass.cpp      |  2 +-
 .../scoped_allocator.version.pass.cpp                  |  2 +-
 .../support.limits.general/set.version.pass.cpp        |  2 +-
 .../shared_mutex.version.pass.cpp                      |  2 +-
 .../support.limits.general/string.version.pass.cpp     |  2 +-
 .../string_view.version.pass.cpp                       |  2 +-
 .../support.limits.general/tuple.version.pass.cpp      |  2 +-
 .../type_traits.version.pass.cpp                       |  2 +-
 .../unordered_map.version.pass.cpp                     |  2 +-
 .../unordered_set.version.pass.cpp                     |  2 +-
 .../support.limits.general/utility.version.pass.cpp    |  2 +-
 .../support.limits.general/variant.version.pass.cpp    |  2 +-
 .../support.limits.general/vector.version.pass.cpp     |  2 +-
 .../support.limits.general/version.version.pass.cpp    |  2 +-
 .../language.support/support.limits/version.pass.cpp   |  4 +++-
 .../support.rtti/bad.cast/bad_cast.pass.cpp            |  4 +++-
 .../support.rtti/bad.typeid/bad_typeid.pass.cpp        |  4 +++-
 .../support.rtti/type.info/type_info.pass.cpp          |  4 +++-
 .../support.rtti/type.info/type_info_hash.pass.cpp     |  4 +++-
 .../language.support/support.runtime/csetjmp.pass.cpp  |  4 +++-
 .../language.support/support.runtime/csignal.pass.cpp  |  4 +++-
 .../language.support/support.runtime/cstdarg.pass.cpp  |  4 +++-
 .../language.support/support.runtime/cstdbool.pass.cpp |  4 +++-
 .../language.support/support.runtime/cstdlib.pass.cpp  |  4 +++-
 .../language.support/support.runtime/ctime.pass.cpp    |  4 +++-
 .../support.start.term/quick_exit.pass.cpp             |  4 +++-
 .../support.start.term/quick_exit_check1.fail.cpp      |  4 +++-
 .../support.start.term/quick_exit_check2.fail.cpp      |  4 +++-
 test/std/language.support/support.types/byte.pass.cpp  |  4 +++-
 .../support.types/byteops/and.assign.pass.cpp          |  4 +++-
 .../support.types/byteops/and.pass.cpp                 |  4 +++-
 .../support.types/byteops/enum_direct_init.pass.cpp    |  4 +++-
 .../support.types/byteops/lshift.assign.fail.cpp       |  4 +++-
 .../support.types/byteops/lshift.assign.pass.cpp       |  4 +++-
 .../support.types/byteops/lshift.fail.cpp              |  4 +++-
 .../support.types/byteops/lshift.pass.cpp              |  4 +++-
 .../support.types/byteops/not.pass.cpp                 |  4 +++-
 .../support.types/byteops/or.assign.pass.cpp           |  4 +++-
 .../language.support/support.types/byteops/or.pass.cpp |  4 +++-
 .../support.types/byteops/rshift.assign.fail.cpp       |  4 +++-
 .../support.types/byteops/rshift.assign.pass.cpp       |  4 +++-
 .../support.types/byteops/rshift.fail.cpp              |  4 +++-
 .../support.types/byteops/rshift.pass.cpp              |  4 +++-
 .../support.types/byteops/to_integer.fail.cpp          |  4 +++-
 .../support.types/byteops/to_integer.pass.cpp          |  4 +++-
 .../support.types/byteops/xor.assign.pass.cpp          |  4 +++-
 .../support.types/byteops/xor.pass.cpp                 |  4 +++-
 .../support.types/max_align_t.pass.cpp                 |  4 +++-
 test/std/language.support/support.types/null.pass.cpp  |  4 +++-
 .../language.support/support.types/nullptr_t.pass.cpp  |  4 +++-
 .../support.types/nullptr_t_integral_cast.fail.cpp     |  4 +++-
 .../support.types/nullptr_t_integral_cast.pass.cpp     |  4 +++-
 .../language.support/support.types/offsetof.pass.cpp   |  4 +++-
 .../language.support/support.types/ptrdiff_t.pass.cpp  |  4 +++-
 .../std/language.support/support.types/size_t.pass.cpp |  4 +++-
 test/std/localization/c.locales/clocale.pass.cpp       |  4 +++-
 .../locale.collate.byname/compare.pass.cpp             |  4 +++-
 .../locale.collate.byname/hash.pass.cpp                |  4 +++-
 .../locale.collate.byname/transform.pass.cpp           |  4 +++-
 .../locale.collate.byname/types.pass.cpp               |  4 +++-
 .../category.collate/locale.collate/ctor.pass.cpp      |  4 +++-
 .../locale.collate.members/compare.pass.cpp            |  4 +++-
 .../locale.collate.members/hash.pass.cpp               |  4 +++-
 .../locale.collate.members/transform.pass.cpp          |  4 +++-
 .../locale.collate.virtuals/tested_elsewhere.pass.cpp  |  4 +++-
 .../category.collate/locale.collate/types.pass.cpp     |  4 +++-
 .../category.collate/nothing_to_do.pass.cpp            |  4 +++-
 .../category.ctype/ctype_base.pass.cpp                 |  4 +++-
 .../facet.ctype.char.dtor/dtor.pass.cpp                |  4 +++-
 .../facet.ctype.char.members/ctor.pass.cpp             |  4 +++-
 .../facet.ctype.char.members/is_1.pass.cpp             |  4 +++-
 .../facet.ctype.char.members/is_many.pass.cpp          |  4 +++-
 .../facet.ctype.char.members/narrow_1.pass.cpp         |  4 +++-
 .../facet.ctype.char.members/narrow_many.pass.cpp      |  4 +++-
 .../facet.ctype.char.members/scan_is.pass.cpp          |  4 +++-
 .../facet.ctype.char.members/scan_not.pass.cpp         |  4 +++-
 .../facet.ctype.char.members/table.pass.cpp            |  4 +++-
 .../facet.ctype.char.members/tolower_1.pass.cpp        |  4 +++-
 .../facet.ctype.char.members/tolower_many.pass.cpp     |  4 +++-
 .../facet.ctype.char.members/toupper_1.pass.cpp        |  4 +++-
 .../facet.ctype.char.members/toupper_many.pass.cpp     |  4 +++-
 .../facet.ctype.char.members/widen_1.pass.cpp          |  4 +++-
 .../facet.ctype.char.members/widen_many.pass.cpp       |  4 +++-
 .../facet.ctype.char.statics/classic_table.pass.cpp    |  4 +++-
 .../tested_elsewhere.pass.cpp                          |  4 +++-
 .../category.ctype/facet.ctype.special/types.pass.cpp  |  4 +++-
 .../locale.codecvt.byname/ctor_char.pass.cpp           |  4 +++-
 .../locale.codecvt.byname/ctor_char16_t.pass.cpp       |  4 +++-
 .../locale.codecvt.byname/ctor_char32_t.pass.cpp       |  4 +++-
 .../locale.codecvt.byname/ctor_wchar_t.pass.cpp        |  4 +++-
 .../locale.codecvt/codecvt_base.pass.cpp               |  4 +++-
 .../category.ctype/locale.codecvt/ctor_char.pass.cpp   |  4 +++-
 .../locale.codecvt/ctor_char16_t.pass.cpp              |  4 +++-
 .../locale.codecvt/ctor_char32_t.pass.cpp              |  4 +++-
 .../locale.codecvt/ctor_wchar_t.pass.cpp               |  4 +++-
 .../char16_t_always_noconv.pass.cpp                    |  4 +++-
 .../locale.codecvt.members/char16_t_encoding.pass.cpp  |  4 +++-
 .../locale.codecvt.members/char16_t_in.pass.cpp        |  4 +++-
 .../locale.codecvt.members/char16_t_length.pass.cpp    |  4 +++-
 .../char16_t_max_length.pass.cpp                       |  4 +++-
 .../locale.codecvt.members/char16_t_out.pass.cpp       |  4 +++-
 .../locale.codecvt.members/char16_t_unshift.pass.cpp   |  4 +++-
 .../char32_t_always_noconv.pass.cpp                    |  4 +++-
 .../locale.codecvt.members/char32_t_encoding.pass.cpp  |  4 +++-
 .../locale.codecvt.members/char32_t_in.pass.cpp        |  4 +++-
 .../locale.codecvt.members/char32_t_length.pass.cpp    |  4 +++-
 .../char32_t_max_length.pass.cpp                       |  4 +++-
 .../locale.codecvt.members/char32_t_out.pass.cpp       |  4 +++-
 .../locale.codecvt.members/char32_t_unshift.pass.cpp   |  4 +++-
 .../locale.codecvt.members/char_always_noconv.pass.cpp |  4 +++-
 .../locale.codecvt.members/char_encoding.pass.cpp      |  4 +++-
 .../locale.codecvt.members/char_in.pass.cpp            |  4 +++-
 .../locale.codecvt.members/char_length.pass.cpp        |  4 +++-
 .../locale.codecvt.members/char_max_length.pass.cpp    |  4 +++-
 .../locale.codecvt.members/char_out.pass.cpp           |  4 +++-
 .../locale.codecvt.members/char_unshift.pass.cpp       |  4 +++-
 .../locale.codecvt.members/utf_sanity_check.pass.cpp   |  4 +++-
 .../wchar_t_always_noconv.pass.cpp                     |  4 +++-
 .../locale.codecvt.members/wchar_t_encoding.pass.cpp   |  4 +++-
 .../locale.codecvt.members/wchar_t_in.pass.cpp         |  4 +++-
 .../locale.codecvt.members/wchar_t_length.pass.cpp     |  4 +++-
 .../locale.codecvt.members/wchar_t_max_length.pass.cpp |  4 +++-
 .../locale.codecvt.members/wchar_t_out.pass.cpp        |  4 +++-
 .../locale.codecvt.members/wchar_t_unshift.pass.cpp    |  4 +++-
 .../locale.codecvt.virtuals/tested_elsewhere.pass.cpp  |  4 +++-
 .../category.ctype/locale.codecvt/types_char.pass.cpp  |  4 +++-
 .../locale.codecvt/types_char16_t.pass.cpp             |  4 +++-
 .../locale.codecvt/types_char32_t.pass.cpp             |  4 +++-
 .../locale.codecvt/types_wchar_t.pass.cpp              |  4 +++-
 .../category.ctype/locale.ctype.byname/is_1.pass.cpp   |  4 +++-
 .../locale.ctype.byname/is_many.pass.cpp               |  4 +++-
 .../category.ctype/locale.ctype.byname/mask.pass.cpp   |  4 +++-
 .../locale.ctype.byname/narrow_1.pass.cpp              |  4 +++-
 .../locale.ctype.byname/narrow_many.pass.cpp           |  4 +++-
 .../locale.ctype.byname/scan_is.pass.cpp               |  4 +++-
 .../locale.ctype.byname/scan_not.pass.cpp              |  4 +++-
 .../locale.ctype.byname/tolower_1.pass.cpp             |  4 +++-
 .../locale.ctype.byname/tolower_many.pass.cpp          |  4 +++-
 .../locale.ctype.byname/toupper_1.pass.cpp             |  4 +++-
 .../locale.ctype.byname/toupper_many.pass.cpp          |  4 +++-
 .../category.ctype/locale.ctype.byname/types.pass.cpp  |  4 +++-
 .../locale.ctype.byname/widen_1.pass.cpp               |  4 +++-
 .../locale.ctype.byname/widen_many.pass.cpp            |  4 +++-
 .../category.ctype/locale.ctype/ctor.pass.cpp          |  4 +++-
 .../locale.ctype/locale.ctype.members/is_1.pass.cpp    |  4 +++-
 .../locale.ctype/locale.ctype.members/is_many.pass.cpp |  4 +++-
 .../locale.ctype.members/narrow_1.pass.cpp             |  4 +++-
 .../locale.ctype.members/narrow_many.pass.cpp          |  4 +++-
 .../locale.ctype/locale.ctype.members/scan_is.pass.cpp |  4 +++-
 .../locale.ctype.members/scan_not.pass.cpp             |  4 +++-
 .../locale.ctype.members/tolower_1.pass.cpp            |  4 +++-
 .../locale.ctype.members/tolower_many.pass.cpp         |  4 +++-
 .../locale.ctype.members/toupper_1.pass.cpp            |  4 +++-
 .../locale.ctype.members/toupper_many.pass.cpp         |  4 +++-
 .../locale.ctype/locale.ctype.members/widen_1.pass.cpp |  4 +++-
 .../locale.ctype.members/widen_many.pass.cpp           |  4 +++-
 .../locale.ctype.virtuals/tested_elsewhere.pass.cpp    |  4 +++-
 .../category.ctype/locale.ctype/types.pass.cpp         |  4 +++-
 .../locale.messages.byname/nothing_to_do.pass.cpp      |  4 +++-
 .../category.messages/locale.messages/ctor.pass.cpp    |  4 +++-
 .../locale.messages.members/not_testable.pass.cpp      |  4 +++-
 .../locale.messages.virtuals/tested_elsewhere.pass.cpp |  4 +++-
 .../locale.messages/messages_base.pass.cpp             |  4 +++-
 .../category.messages/locale.messages/types.pass.cpp   |  4 +++-
 .../category.messages/nothing_to_do.pass.cpp           |  4 +++-
 .../category.monetary/locale.money.get/ctor.pass.cpp   |  4 +++-
 .../get_long_double_en_US.pass.cpp                     |  4 +++-
 .../get_long_double_fr_FR.pass.cpp                     |  4 +++-
 .../get_long_double_ru_RU.pass.cpp                     |  4 +++-
 .../get_long_double_zh_CN.pass.cpp                     |  4 +++-
 .../locale.money.get.members/get_string_en_US.pass.cpp |  4 +++-
 .../tested_elsewhere.pass.cpp                          |  4 +++-
 .../category.monetary/locale.money.get/types.pass.cpp  |  4 +++-
 .../category.monetary/locale.money.put/ctor.pass.cpp   |  4 +++-
 .../put_long_double_en_US.pass.cpp                     |  4 +++-
 .../put_long_double_fr_FR.pass.cpp                     |  4 +++-
 .../put_long_double_ru_RU.pass.cpp                     |  4 +++-
 .../put_long_double_zh_CN.pass.cpp                     |  4 +++-
 .../locale.money.put.members/put_string_en_US.pass.cpp |  4 +++-
 .../tested_elsewhere.pass.cpp                          |  4 +++-
 .../category.monetary/locale.money.put/types.pass.cpp  |  4 +++-
 .../locale.moneypunct.byname/curr_symbol.pass.cpp      |  4 +++-
 .../locale.moneypunct.byname/decimal_point.pass.cpp    |  4 +++-
 .../locale.moneypunct.byname/frac_digits.pass.cpp      |  4 +++-
 .../locale.moneypunct.byname/grouping.pass.cpp         |  4 +++-
 .../locale.moneypunct.byname/neg_format.pass.cpp       |  4 +++-
 .../locale.moneypunct.byname/negative_sign.pass.cpp    |  4 +++-
 .../locale.moneypunct.byname/pos_format.pass.cpp       |  4 +++-
 .../locale.moneypunct.byname/positive_sign.pass.cpp    |  4 +++-
 .../locale.moneypunct.byname/thousands_sep.pass.cpp    |  4 +++-
 .../category.monetary/locale.moneypunct/ctor.pass.cpp  |  4 +++-
 .../locale.moneypunct.members/curr_symbol.pass.cpp     |  4 +++-
 .../locale.moneypunct.members/decimal_point.pass.cpp   |  4 +++-
 .../locale.moneypunct.members/frac_digits.pass.cpp     |  4 +++-
 .../locale.moneypunct.members/grouping.pass.cpp        |  4 +++-
 .../locale.moneypunct.members/neg_format.pass.cpp      |  4 +++-
 .../locale.moneypunct.members/negative_sign.pass.cpp   |  4 +++-
 .../locale.moneypunct.members/pos_format.pass.cpp      |  4 +++-
 .../locale.moneypunct.members/positive_sign.pass.cpp   |  4 +++-
 .../locale.moneypunct.members/thousands_sep.pass.cpp   |  4 +++-
 .../tested_elsewhere.pass.cpp                          |  4 +++-
 .../locale.moneypunct/money_base.pass.cpp              |  4 +++-
 .../category.monetary/locale.moneypunct/types.pass.cpp |  4 +++-
 .../category.monetary/nothing_to_do.pass.cpp           |  4 +++-
 .../category.numeric/locale.nm.put/ctor.pass.cpp       |  4 +++-
 .../facet.num.put.members/put_bool.pass.cpp            |  4 +++-
 .../facet.num.put.members/put_double.pass.cpp          |  4 +++-
 .../facet.num.put.members/put_long.pass.cpp            |  4 +++-
 .../facet.num.put.members/put_long_double.pass.cpp     |  4 +++-
 .../facet.num.put.members/put_long_long.pass.cpp       |  4 +++-
 .../facet.num.put.members/put_pointer.pass.cpp         |  4 +++-
 .../facet.num.put.members/put_unsigned_long.pass.cpp   |  4 +++-
 .../put_unsigned_long_long.pass.cpp                    |  4 +++-
 .../facet.num.put.virtuals/tested_elsewhere.pass.cpp   |  4 +++-
 .../category.numeric/locale.nm.put/types.pass.cpp      |  4 +++-
 .../category.numeric/locale.num.get/ctor.pass.cpp      |  4 +++-
 .../facet.num.get.members/get_bool.pass.cpp            |  4 +++-
 .../facet.num.get.members/get_double.pass.cpp          |  4 +++-
 .../facet.num.get.members/get_float.pass.cpp           |  4 +++-
 .../facet.num.get.members/get_long.pass.cpp            |  4 +++-
 .../facet.num.get.members/get_long_double.pass.cpp     |  4 +++-
 .../facet.num.get.members/get_long_long.pass.cpp       |  4 +++-
 .../facet.num.get.members/get_pointer.pass.cpp         |  4 +++-
 .../facet.num.get.members/get_unsigned_int.pass.cpp    |  4 +++-
 .../facet.num.get.members/get_unsigned_long.pass.cpp   |  4 +++-
 .../get_unsigned_long_long.pass.cpp                    |  4 +++-
 .../facet.num.get.members/get_unsigned_short.pass.cpp  |  4 +++-
 .../facet.num.get.members/test_min_max.pass.cpp        |  4 +++-
 .../facet.num.get.members/test_neg_one.pass.cpp        |  4 +++-
 .../facet.num.get.virtuals/tested_elsewhere.pass.cpp   |  4 +++-
 .../category.numeric/locale.num.get/types.pass.cpp     |  4 +++-
 .../category.numeric/nothing_to_do.pass.cpp            |  4 +++-
 .../locale.time.get.byname/date_order.pass.cpp         |  4 +++-
 .../locale.time.get.byname/date_order_wide.pass.cpp    |  4 +++-
 .../locale.time.get.byname/get_date.pass.cpp           |  4 +++-
 .../locale.time.get.byname/get_date_wide.pass.cpp      |  4 +++-
 .../locale.time.get.byname/get_monthname.pass.cpp      |  4 +++-
 .../locale.time.get.byname/get_monthname_wide.pass.cpp |  4 +++-
 .../locale.time.get.byname/get_one.pass.cpp            |  4 +++-
 .../locale.time.get.byname/get_one_wide.pass.cpp       |  4 +++-
 .../locale.time.get.byname/get_time.pass.cpp           |  4 +++-
 .../locale.time.get.byname/get_time_wide.pass.cpp      |  4 +++-
 .../locale.time.get.byname/get_weekday.pass.cpp        |  4 +++-
 .../locale.time.get.byname/get_weekday_wide.pass.cpp   |  4 +++-
 .../locale.time.get.byname/get_year.pass.cpp           |  4 +++-
 .../locale.time.get.byname/get_year_wide.pass.cpp      |  4 +++-
 .../category.time/locale.time.get/ctor.pass.cpp        |  4 +++-
 .../locale.time.get.members/date_order.pass.cpp        |  4 +++-
 .../locale.time.get.members/get_date.pass.cpp          |  4 +++-
 .../locale.time.get.members/get_date_wide.pass.cpp     |  4 +++-
 .../locale.time.get.members/get_many.pass.cpp          |  4 +++-
 .../locale.time.get.members/get_monthname.pass.cpp     |  4 +++-
 .../get_monthname_wide.pass.cpp                        |  4 +++-
 .../locale.time.get.members/get_one.pass.cpp           |  4 +++-
 .../locale.time.get.members/get_time.pass.cpp          |  4 +++-
 .../locale.time.get.members/get_time_wide.pass.cpp     |  4 +++-
 .../locale.time.get.members/get_weekday.pass.cpp       |  4 +++-
 .../locale.time.get.members/get_weekday_wide.pass.cpp  |  4 +++-
 .../locale.time.get.members/get_year.pass.cpp          |  4 +++-
 .../locale.time.get.virtuals/tested_elsewhere.pass.cpp |  4 +++-
 .../category.time/locale.time.get/time_base.pass.cpp   |  4 +++-
 .../category.time/locale.time.get/types.pass.cpp       |  4 +++-
 .../category.time/locale.time.put.byname/put1.pass.cpp |  4 +++-
 .../category.time/locale.time.put/ctor.pass.cpp        |  4 +++-
 .../locale.time.put.members/put1.pass.cpp              |  4 +++-
 .../locale.time.put.members/put2.pass.cpp              |  4 +++-
 .../locale.time.put.virtuals/tested_elsewhere.pass.cpp |  4 +++-
 .../category.time/locale.time.put/types.pass.cpp       |  4 +++-
 .../category.time/nothing_to_do.pass.cpp               |  4 +++-
 .../locale.numpunct.byname/decimal_point.pass.cpp      |  4 +++-
 .../locale.numpunct.byname/grouping.pass.cpp           |  4 +++-
 .../locale.numpunct.byname/thousands_sep.pass.cpp      |  4 +++-
 .../facet.numpunct/locale.numpunct/ctor.pass.cpp       |  4 +++-
 .../facet.numpunct.members/decimal_point.pass.cpp      |  4 +++-
 .../facet.numpunct.members/falsename.pass.cpp          |  4 +++-
 .../facet.numpunct.members/grouping.pass.cpp           |  4 +++-
 .../facet.numpunct.members/thousands_sep.pass.cpp      |  4 +++-
 .../facet.numpunct.members/truename.pass.cpp           |  4 +++-
 .../facet.numpunct.virtuals/tested_elsewhere.pass.cpp  |  4 +++-
 .../facet.numpunct/locale.numpunct/types.pass.cpp      |  4 +++-
 .../facet.numpunct/nothing_to_do.pass.cpp              |  4 +++-
 .../facets.examples/nothing_to_do.pass.cpp             |  4 +++-
 .../localization/locale.stdcvt/codecvt_mode.pass.cpp   |  4 +++-
 .../localization/locale.stdcvt/codecvt_utf16.pass.cpp  |  4 +++-
 .../locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp |  4 +++-
 .../locale.stdcvt/codecvt_utf16_encoding.pass.cpp      |  4 +++-
 .../locale.stdcvt/codecvt_utf16_in.pass.cpp            |  4 +++-
 .../locale.stdcvt/codecvt_utf16_length.pass.cpp        |  4 +++-
 .../locale.stdcvt/codecvt_utf16_max_length.pass.cpp    |  4 +++-
 .../locale.stdcvt/codecvt_utf16_out.pass.cpp           |  4 +++-
 .../locale.stdcvt/codecvt_utf16_unshift.pass.cpp       |  4 +++-
 .../localization/locale.stdcvt/codecvt_utf8.pass.cpp   |  4 +++-
 .../locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp  |  4 +++-
 .../locale.stdcvt/codecvt_utf8_encoding.pass.cpp       |  4 +++-
 .../locale.stdcvt/codecvt_utf8_in.pass.cpp             |  4 +++-
 .../locale.stdcvt/codecvt_utf8_length.pass.cpp         |  4 +++-
 .../locale.stdcvt/codecvt_utf8_max_length.pass.cpp     |  4 +++-
 .../locale.stdcvt/codecvt_utf8_out.pass.cpp            |  4 +++-
 .../locale.stdcvt/codecvt_utf8_unshift.pass.cpp        |  4 +++-
 .../codecvt_utf8_utf16_always_noconv.pass.cpp          |  4 +++-
 .../locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp |  4 +++-
 .../locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp       |  4 +++-
 .../locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp   |  4 +++-
 .../codecvt_utf8_utf16_max_length.pass.cpp             |  4 +++-
 .../locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp      |  4 +++-
 .../locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp  |  4 +++-
 .../std/localization/locale.syn/nothing_to_do.pass.cpp |  4 +++-
 .../locale.convenience/classification/isalnum.pass.cpp |  4 +++-
 .../locale.convenience/classification/isalpha.pass.cpp |  4 +++-
 .../locale.convenience/classification/iscntrl.pass.cpp |  4 +++-
 .../locale.convenience/classification/isdigit.pass.cpp |  4 +++-
 .../locale.convenience/classification/isgraph.pass.cpp |  4 +++-
 .../locale.convenience/classification/islower.pass.cpp |  4 +++-
 .../locale.convenience/classification/isprint.pass.cpp |  4 +++-
 .../locale.convenience/classification/ispunct.pass.cpp |  4 +++-
 .../locale.convenience/classification/isspace.pass.cpp |  4 +++-
 .../locale.convenience/classification/isupper.pass.cpp |  4 +++-
 .../classification/isxdigit.pass.cpp                   |  4 +++-
 .../conversions/conversions.buffer/ctor.pass.cpp       |  4 +++-
 .../conversions/conversions.buffer/overflow.pass.cpp   |  4 +++-
 .../conversions/conversions.buffer/pbackfail.pass.cpp  |  4 +++-
 .../conversions/conversions.buffer/rdbuf.pass.cpp      |  4 +++-
 .../conversions/conversions.buffer/seekoff.pass.cpp    |  4 +++-
 .../conversions/conversions.buffer/state.pass.cpp      |  4 +++-
 .../conversions/conversions.buffer/test.pass.cpp       |  4 +++-
 .../conversions/conversions.buffer/underflow.pass.cpp  |  4 +++-
 .../conversions/conversions.character/tolower.pass.cpp |  4 +++-
 .../conversions/conversions.character/toupper.pass.cpp |  4 +++-
 .../conversions/conversions.string/converted.pass.cpp  |  4 +++-
 .../conversions.string/ctor_codecvt.pass.cpp           |  4 +++-
 .../conversions.string/ctor_codecvt_state.pass.cpp     |  4 +++-
 .../conversions/conversions.string/ctor_copy.pass.cpp  |  4 +++-
 .../conversions.string/ctor_err_string.pass.cpp        |  4 +++-
 .../conversions/conversions.string/from_bytes.pass.cpp |  4 +++-
 .../conversions/conversions.string/state.pass.cpp      |  4 +++-
 .../conversions/conversions.string/to_bytes.pass.cpp   |  4 +++-
 .../conversions/conversions.string/types.pass.cpp      |  4 +++-
 .../conversions/nothing_to_do.pass.cpp                 |  4 +++-
 .../locales/locale.convenience/nothing_to_do.pass.cpp  |  4 +++-
 .../locales/locale.global.templates/has_facet.pass.cpp |  4 +++-
 .../locales/locale.global.templates/use_facet.pass.cpp |  4 +++-
 .../locales/locale/locale.cons/assign.pass.cpp         |  4 +++-
 .../locales/locale/locale.cons/char_pointer.pass.cpp   |  4 +++-
 .../locales/locale/locale.cons/copy.pass.cpp           |  4 +++-
 .../locales/locale/locale.cons/default.pass.cpp        |  4 +++-
 .../locale.cons/locale_char_pointer_cat.pass.cpp       |  4 +++-
 .../locale/locale.cons/locale_facetptr.pass.cpp        |  4 +++-
 .../locale/locale.cons/locale_locale_cat.pass.cpp      |  4 +++-
 .../locale/locale.cons/locale_string_cat.pass.cpp      |  4 +++-
 .../locales/locale/locale.cons/string.pass.cpp         |  4 +++-
 .../locales/locale/locale.members/combine.pass.cpp     |  4 +++-
 .../locales/locale/locale.members/name.pass.cpp        |  4 +++-
 .../locales/locale/locale.operators/compare.pass.cpp   |  4 +++-
 .../locales/locale/locale.operators/eq.pass.cpp        |  4 +++-
 .../locales/locale/locale.statics/classic.pass.cpp     |  4 +++-
 .../locales/locale/locale.statics/global.pass.cpp      |  4 +++-
 .../locale.types/locale.category/category.pass.cpp     |  4 +++-
 .../locale.facet/tested_elsewhere.pass.cpp             |  4 +++-
 .../locale.types/locale.id/tested_elsewhere.pass.cpp   |  4 +++-
 .../locales/locale/locale.types/nothing_to_do.pass.cpp |  4 +++-
 .../localization/locales/locale/nothing_to_do.pass.cpp |  4 +++-
 test/std/localization/locales/nothing_to_do.pass.cpp   |  4 +++-
 .../localization.general/nothing_to_do.pass.cpp        |  4 +++-
 test/std/nothing_to_do.pass.cpp                        |  4 +++-
 test/std/numerics/c.math/cmath.pass.cpp                |  4 +++-
 test/std/numerics/c.math/ctgmath.pass.cpp              |  4 +++-
 test/std/numerics/c.math/tgmath_h.pass.cpp             |  4 +++-
 test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp       |  4 +++-
 .../numerics/complex.number/ccmplx/ccomplex.pass.cpp   |  4 +++-
 .../complex.number/cmplx.over/UDT_is_rejected.fail.cpp |  4 +++-
 .../numerics/complex.number/cmplx.over/arg.pass.cpp    |  4 +++-
 .../numerics/complex.number/cmplx.over/conj.pass.cpp   |  4 +++-
 .../numerics/complex.number/cmplx.over/imag.pass.cpp   |  4 +++-
 .../numerics/complex.number/cmplx.over/norm.pass.cpp   |  4 +++-
 .../numerics/complex.number/cmplx.over/pow.pass.cpp    |  4 +++-
 .../numerics/complex.number/cmplx.over/proj.pass.cpp   |  4 +++-
 .../numerics/complex.number/cmplx.over/real.pass.cpp   |  4 +++-
 .../complex.number/complex.literals/literals.pass.cpp  |  4 +++-
 .../complex.number/complex.literals/literals1.fail.cpp |  4 +++-
 .../complex.number/complex.literals/literals1.pass.cpp |  4 +++-
 .../complex.number/complex.literals/literals2.pass.cpp |  4 +++-
 .../complex.member.ops/assignment_complex.pass.cpp     |  4 +++-
 .../complex.member.ops/assignment_scalar.pass.cpp      |  4 +++-
 .../complex.member.ops/divide_equal_complex.pass.cpp   |  4 +++-
 .../complex.member.ops/divide_equal_scalar.pass.cpp    |  4 +++-
 .../complex.member.ops/minus_equal_complex.pass.cpp    |  4 +++-
 .../complex.member.ops/minus_equal_scalar.pass.cpp     |  4 +++-
 .../complex.member.ops/plus_equal_complex.pass.cpp     |  4 +++-
 .../complex.member.ops/plus_equal_scalar.pass.cpp      |  4 +++-
 .../complex.member.ops/times_equal_complex.pass.cpp    |  4 +++-
 .../complex.member.ops/times_equal_scalar.pass.cpp     |  4 +++-
 .../complex.number/complex.members/construct.pass.cpp  |  4 +++-
 .../complex.number/complex.members/real_imag.pass.cpp  |  4 +++-
 .../complex.ops/complex_divide_complex.pass.cpp        |  4 +++-
 .../complex.ops/complex_divide_scalar.pass.cpp         |  4 +++-
 .../complex.ops/complex_equals_complex.pass.cpp        |  4 +++-
 .../complex.ops/complex_equals_scalar.pass.cpp         |  4 +++-
 .../complex.ops/complex_minus_complex.pass.cpp         |  4 +++-
 .../complex.ops/complex_minus_scalar.pass.cpp          |  4 +++-
 .../complex.ops/complex_not_equals_complex.pass.cpp    |  4 +++-
 .../complex.ops/complex_not_equals_scalar.pass.cpp     |  6 ++++--
 .../complex.ops/complex_plus_complex.pass.cpp          |  4 +++-
 .../complex.ops/complex_plus_scalar.pass.cpp           |  4 +++-
 .../complex.ops/complex_times_complex.pass.cpp         |  4 +++-
 .../complex.ops/complex_times_scalar.pass.cpp          |  4 +++-
 .../complex.ops/scalar_divide_complex.pass.cpp         |  4 +++-
 .../complex.ops/scalar_equals_complex.pass.cpp         |  4 +++-
 .../complex.ops/scalar_minus_complex.pass.cpp          |  4 +++-
 .../complex.ops/scalar_not_equals_complex.pass.cpp     |  4 +++-
 .../complex.ops/scalar_plus_complex.pass.cpp           |  4 +++-
 .../complex.ops/scalar_times_complex.pass.cpp          |  4 +++-
 .../complex.number/complex.ops/stream_input.pass.cpp   |  4 +++-
 .../complex.number/complex.ops/stream_output.pass.cpp  |  4 +++-
 .../complex.number/complex.ops/unary_minus.pass.cpp    |  4 +++-
 .../complex.number/complex.ops/unary_plus.pass.cpp     |  4 +++-
 .../complex.special/double_float_explicit.pass.cpp     |  4 +++-
 .../complex.special/double_float_implicit.pass.cpp     |  4 +++-
 .../double_long_double_explicit.pass.cpp               |  4 +++-
 .../double_long_double_implicit.fail.cpp               |  4 +++-
 .../complex.special/float_double_explicit.pass.cpp     |  4 +++-
 .../complex.special/float_double_implicit.fail.cpp     |  4 +++-
 .../float_long_double_explicit.pass.cpp                |  4 +++-
 .../float_long_double_implicit.fail.cpp                |  4 +++-
 .../long_double_double_explicit.pass.cpp               |  4 +++-
 .../long_double_double_implicit.pass.cpp               |  4 +++-
 .../long_double_float_explicit.pass.cpp                |  4 +++-
 .../long_double_float_implicit.pass.cpp                |  4 +++-
 .../complex.synopsis/nothing_to_do.pass.cpp            |  4 +++-
 .../complex.transcendentals/acos.pass.cpp              |  4 +++-
 .../complex.transcendentals/acosh.pass.cpp             |  4 +++-
 .../complex.transcendentals/asin.pass.cpp              |  4 +++-
 .../complex.transcendentals/asinh.pass.cpp             |  4 +++-
 .../complex.transcendentals/atan.pass.cpp              |  4 +++-
 .../complex.transcendentals/atanh.pass.cpp             |  4 +++-
 .../complex.transcendentals/cos.pass.cpp               |  4 +++-
 .../complex.transcendentals/cosh.pass.cpp              |  4 +++-
 .../complex.transcendentals/exp.pass.cpp               |  4 +++-
 .../complex.transcendentals/log.pass.cpp               |  4 +++-
 .../complex.transcendentals/log10.pass.cpp             |  4 +++-
 .../pow_complex_complex.pass.cpp                       |  4 +++-
 .../pow_complex_scalar.pass.cpp                        |  4 +++-
 .../pow_scalar_complex.pass.cpp                        |  4 +++-
 .../complex.transcendentals/sin.pass.cpp               |  4 +++-
 .../complex.transcendentals/sinh.pass.cpp              |  4 +++-
 .../complex.transcendentals/sqrt.pass.cpp              |  4 +++-
 .../complex.transcendentals/tan.pass.cpp               |  4 +++-
 .../complex.transcendentals/tanh.pass.cpp              |  4 +++-
 .../complex.number/complex.value.ops/abs.pass.cpp      |  4 +++-
 .../complex.number/complex.value.ops/arg.pass.cpp      |  4 +++-
 .../complex.number/complex.value.ops/conj.pass.cpp     |  4 +++-
 .../complex.number/complex.value.ops/imag.pass.cpp     |  4 +++-
 .../complex.number/complex.value.ops/norm.pass.cpp     |  4 +++-
 .../complex.number/complex.value.ops/polar.pass.cpp    |  4 +++-
 .../complex.number/complex.value.ops/proj.pass.cpp     |  4 +++-
 .../complex.number/complex.value.ops/real.pass.cpp     |  4 +++-
 .../std/numerics/complex.number/complex/types.pass.cpp |  4 +++-
 test/std/numerics/complex.number/layout.pass.cpp       |  4 +++-
 test/std/numerics/nothing_to_do.pass.cpp               |  4 +++-
 .../gslice.access/tested_elsewhere.pass.cpp            |  4 +++-
 .../numarray/class.gslice/gslice.cons/default.pass.cpp |  4 +++-
 .../gslice.cons/start_size_stride.pass.cpp             |  4 +++-
 .../numarray/class.gslice/nothing_to_do.pass.cpp       |  4 +++-
 .../numarray/class.slice/cons.slice/default.pass.cpp   |  4 +++-
 .../class.slice/cons.slice/start_size_stride.pass.cpp  |  4 +++-
 .../numarray/class.slice/nothing_to_do.pass.cpp        |  4 +++-
 .../class.slice/slice.access/tested_elsewhere.pass.cpp |  4 +++-
 .../numarray/template.gslice.array/default.fail.cpp    |  4 +++-
 .../gslice.array.assign/gslice_array.pass.cpp          |  4 +++-
 .../gslice.array.assign/valarray.pass.cpp              |  4 +++-
 .../gslice.array.comp.assign/addition.pass.cpp         |  4 +++-
 .../gslice.array.comp.assign/and.pass.cpp              |  4 +++-
 .../gslice.array.comp.assign/divide.pass.cpp           |  4 +++-
 .../gslice.array.comp.assign/modulo.pass.cpp           |  4 +++-
 .../gslice.array.comp.assign/multiply.pass.cpp         |  4 +++-
 .../gslice.array.comp.assign/or.pass.cpp               |  4 +++-
 .../gslice.array.comp.assign/shift_left.pass.cpp       |  4 +++-
 .../gslice.array.comp.assign/shift_right.pass.cpp      |  4 +++-
 .../gslice.array.comp.assign/subtraction.pass.cpp      |  4 +++-
 .../gslice.array.comp.assign/xor.pass.cpp              |  4 +++-
 .../gslice.array.fill/assign_value.pass.cpp            |  4 +++-
 .../numarray/template.gslice.array/types.pass.cpp      |  4 +++-
 .../numarray/template.indirect.array/default.fail.cpp  |  4 +++-
 .../indirect.array.assign/indirect_array.pass.cpp      |  4 +++-
 .../indirect.array.assign/valarray.pass.cpp            |  4 +++-
 .../indirect.array.comp.assign/addition.pass.cpp       |  4 +++-
 .../indirect.array.comp.assign/and.pass.cpp            |  4 +++-
 .../indirect.array.comp.assign/divide.pass.cpp         |  4 +++-
 .../indirect.array.comp.assign/modulo.pass.cpp         |  4 +++-
 .../indirect.array.comp.assign/multiply.pass.cpp       |  4 +++-
 .../indirect.array.comp.assign/or.pass.cpp             |  4 +++-
 .../indirect.array.comp.assign/shift_left.pass.cpp     |  4 +++-
 .../indirect.array.comp.assign/shift_right.pass.cpp    |  4 +++-
 .../indirect.array.comp.assign/subtraction.pass.cpp    |  4 +++-
 .../indirect.array.comp.assign/xor.pass.cpp            |  4 +++-
 .../indirect.array.fill/assign_value.pass.cpp          |  4 +++-
 .../numarray/template.indirect.array/types.pass.cpp    |  4 +++-
 .../numarray/template.mask.array/default.fail.cpp      |  4 +++-
 .../mask.array.assign/mask_array.pass.cpp              |  4 +++-
 .../mask.array.assign/valarray.pass.cpp                |  4 +++-
 .../mask.array.comp.assign/addition.pass.cpp           |  4 +++-
 .../mask.array.comp.assign/and.pass.cpp                |  4 +++-
 .../mask.array.comp.assign/divide.pass.cpp             |  4 +++-
 .../mask.array.comp.assign/modulo.pass.cpp             |  4 +++-
 .../mask.array.comp.assign/multiply.pass.cpp           |  4 +++-
 .../mask.array.comp.assign/or.pass.cpp                 |  4 +++-
 .../mask.array.comp.assign/shift_left.pass.cpp         |  4 +++-
 .../mask.array.comp.assign/shift_right.pass.cpp        |  4 +++-
 .../mask.array.comp.assign/subtraction.pass.cpp        |  4 +++-
 .../mask.array.comp.assign/xor.pass.cpp                |  4 +++-
 .../mask.array.fill/assign_value.pass.cpp              |  4 +++-
 .../numarray/template.mask.array/types.pass.cpp        |  4 +++-
 .../numarray/template.slice.array/default.fail.cpp     |  4 +++-
 .../slice.arr.assign/slice_array.pass.cpp              |  4 +++-
 .../slice.arr.assign/valarray.pass.cpp                 |  4 +++-
 .../slice.arr.comp.assign/addition.pass.cpp            |  4 +++-
 .../slice.arr.comp.assign/and.pass.cpp                 |  4 +++-
 .../slice.arr.comp.assign/divide.pass.cpp              |  4 +++-
 .../slice.arr.comp.assign/modulo.pass.cpp              |  4 +++-
 .../slice.arr.comp.assign/multiply.pass.cpp            |  4 +++-
 .../slice.arr.comp.assign/or.pass.cpp                  |  4 +++-
 .../slice.arr.comp.assign/shift_left.pass.cpp          |  4 +++-
 .../slice.arr.comp.assign/shift_right.pass.cpp         |  4 +++-
 .../slice.arr.comp.assign/subtraction.pass.cpp         |  4 +++-
 .../slice.arr.comp.assign/xor.pass.cpp                 |  4 +++-
 .../slice.arr.fill/assign_value.pass.cpp               |  4 +++-
 .../numarray/template.slice.array/types.pass.cpp       |  4 +++-
 .../numerics/numarray/template.valarray/types.pass.cpp |  4 +++-
 .../template.valarray/valarray.access/access.pass.cpp  |  4 +++-
 .../valarray.access/const_access.pass.cpp              |  4 +++-
 .../valarray.assign/copy_assign.pass.cpp               |  4 +++-
 .../valarray.assign/gslice_array_assign.pass.cpp       |  4 +++-
 .../valarray.assign/indirect_array_assign.pass.cpp     |  4 +++-
 .../valarray.assign/initializer_list_assign.pass.cpp   |  4 +++-
 .../valarray.assign/mask_array_assign.pass.cpp         |  4 +++-
 .../valarray.assign/move_assign.pass.cpp               |  4 +++-
 .../valarray.assign/slice_array_assign.pass.cpp        |  4 +++-
 .../valarray.assign/value_assign.pass.cpp              |  4 +++-
 .../valarray.cassign/and_valarray.pass.cpp             |  4 +++-
 .../valarray.cassign/and_value.pass.cpp                |  4 +++-
 .../valarray.cassign/divide_valarray.pass.cpp          |  4 +++-
 .../valarray.cassign/divide_value.pass.cpp             |  4 +++-
 .../valarray.cassign/minus_valarray.pass.cpp           |  4 +++-
 .../valarray.cassign/minus_value.pass.cpp              |  4 +++-
 .../valarray.cassign/modulo_valarray.pass.cpp          |  4 +++-
 .../valarray.cassign/modulo_value.pass.cpp             |  4 +++-
 .../valarray.cassign/or_valarray.pass.cpp              |  4 +++-
 .../valarray.cassign/or_value.pass.cpp                 |  4 +++-
 .../valarray.cassign/plus_valarray.pass.cpp            |  4 +++-
 .../valarray.cassign/plus_value.pass.cpp               |  4 +++-
 .../valarray.cassign/shift_left_valarray.pass.cpp      |  4 +++-
 .../valarray.cassign/shift_left_value.pass.cpp         |  4 +++-
 .../valarray.cassign/shift_right_valarray.pass.cpp     |  4 +++-
 .../valarray.cassign/shift_right_value.pass.cpp        |  4 +++-
 .../valarray.cassign/times_valarray.pass.cpp           |  4 +++-
 .../valarray.cassign/times_value.pass.cpp              |  4 +++-
 .../valarray.cassign/xor_valarray.pass.cpp             |  4 +++-
 .../valarray.cassign/xor_value.pass.cpp                |  4 +++-
 .../template.valarray/valarray.cons/copy.pass.cpp      |  4 +++-
 .../template.valarray/valarray.cons/default.pass.cpp   |  4 +++-
 .../valarray.cons/gslice_array.pass.cpp                |  4 +++-
 .../valarray.cons/indirect_array.pass.cpp              |  4 +++-
 .../valarray.cons/initializer_list.pass.cpp            |  4 +++-
 .../valarray.cons/mask_array.pass.cpp                  |  4 +++-
 .../template.valarray/valarray.cons/move.pass.cpp      |  4 +++-
 .../valarray.cons/pointer_size.pass.cpp                |  4 +++-
 .../template.valarray/valarray.cons/size.pass.cpp      |  4 +++-
 .../valarray.cons/slice_array.pass.cpp                 |  4 +++-
 .../valarray.cons/value_size.pass.cpp                  |  4 +++-
 .../valarray.members/apply_cref.pass.cpp               |  4 +++-
 .../valarray.members/apply_value.pass.cpp              |  4 +++-
 .../template.valarray/valarray.members/cshift.pass.cpp |  4 +++-
 .../template.valarray/valarray.members/max.pass.cpp    |  4 +++-
 .../template.valarray/valarray.members/min.pass.cpp    |  4 +++-
 .../template.valarray/valarray.members/resize.pass.cpp |  4 +++-
 .../template.valarray/valarray.members/shift.pass.cpp  |  4 +++-
 .../template.valarray/valarray.members/size.pass.cpp   |  4 +++-
 .../template.valarray/valarray.members/sum.pass.cpp    |  4 +++-
 .../template.valarray/valarray.members/swap.pass.cpp   |  4 +++-
 .../valarray.sub/gslice_const.pass.cpp                 |  4 +++-
 .../valarray.sub/gslice_non_const.pass.cpp             |  4 +++-
 .../valarray.sub/indirect_array_const.pass.cpp         |  4 +++-
 .../valarray.sub/indirect_array_non_const.pass.cpp     |  4 +++-
 .../valarray.sub/slice_const.pass.cpp                  |  4 +++-
 .../valarray.sub/slice_non_const.pass.cpp              |  4 +++-
 .../valarray.sub/valarray_bool_const.pass.cpp          |  4 +++-
 .../valarray.sub/valarray_bool_non_const.pass.cpp      |  4 +++-
 .../template.valarray/valarray.unary/bit_not.pass.cpp  |  4 +++-
 .../template.valarray/valarray.unary/negate.pass.cpp   |  4 +++-
 .../template.valarray/valarray.unary/not.pass.cpp      |  4 +++-
 .../template.valarray/valarray.unary/plus.pass.cpp     |  4 +++-
 .../valarray.nonmembers/nothing_to_do.pass.cpp         |  4 +++-
 .../valarray.binary/and_valarray_valarray.pass.cpp     |  4 +++-
 .../valarray.binary/and_valarray_value.pass.cpp        |  4 +++-
 .../valarray.binary/and_value_valarray.pass.cpp        |  4 +++-
 .../valarray.binary/divide_valarray_valarray.pass.cpp  |  4 +++-
 .../valarray.binary/divide_valarray_value.pass.cpp     |  4 +++-
 .../valarray.binary/divide_value_valarray.pass.cpp     |  4 +++-
 .../valarray.binary/minus_valarray_valarray.pass.cpp   |  4 +++-
 .../valarray.binary/minus_valarray_value.pass.cpp      |  4 +++-
 .../valarray.binary/minus_value_valarray.pass.cpp      |  4 +++-
 .../valarray.binary/modulo_valarray_valarray.pass.cpp  |  4 +++-
 .../valarray.binary/modulo_valarray_value.pass.cpp     |  4 +++-
 .../valarray.binary/modulo_value_valarray.pass.cpp     |  4 +++-
 .../valarray.binary/or_valarray_valarray.pass.cpp      |  4 +++-
 .../valarray.binary/or_valarray_value.pass.cpp         |  4 +++-
 .../valarray.binary/or_value_valarray.pass.cpp         |  4 +++-
 .../valarray.binary/plus_valarray_valarray.pass.cpp    |  4 +++-
 .../valarray.binary/plus_valarray_value.pass.cpp       |  4 +++-
 .../valarray.binary/plus_value_valarray.pass.cpp       |  4 +++-
 .../shift_left_valarray_valarray.pass.cpp              |  4 +++-
 .../valarray.binary/shift_left_valarray_value.pass.cpp |  4 +++-
 .../valarray.binary/shift_left_value_valarray.pass.cpp |  4 +++-
 .../shift_right_valarray_valarray.pass.cpp             |  4 +++-
 .../shift_right_valarray_value.pass.cpp                |  4 +++-
 .../shift_right_value_valarray.pass.cpp                |  4 +++-
 .../valarray.binary/times_valarray_valarray.pass.cpp   |  4 +++-
 .../valarray.binary/times_valarray_value.pass.cpp      |  4 +++-
 .../valarray.binary/times_value_valarray.pass.cpp      |  4 +++-
 .../valarray.binary/xor_valarray_valarray.pass.cpp     |  4 +++-
 .../valarray.binary/xor_valarray_value.pass.cpp        |  4 +++-
 .../valarray.binary/xor_value_valarray.pass.cpp        |  4 +++-
 .../valarray.comparison/and_valarray_valarray.pass.cpp |  4 +++-
 .../valarray.comparison/and_valarray_value.pass.cpp    |  4 +++-
 .../valarray.comparison/and_value_valarray.pass.cpp    |  4 +++-
 .../equal_valarray_valarray.pass.cpp                   |  4 +++-
 .../valarray.comparison/equal_valarray_value.pass.cpp  |  4 +++-
 .../valarray.comparison/equal_value_valarray.pass.cpp  |  4 +++-
 .../greater_equal_valarray_valarray.pass.cpp           |  4 +++-
 .../greater_equal_valarray_value.pass.cpp              |  4 +++-
 .../greater_equal_value_valarray.pass.cpp              |  4 +++-
 .../greater_valarray_valarray.pass.cpp                 |  4 +++-
 .../greater_valarray_value.pass.cpp                    |  4 +++-
 .../greater_value_valarray.pass.cpp                    |  4 +++-
 .../less_equal_valarray_valarray.pass.cpp              |  4 +++-
 .../less_equal_valarray_value.pass.cpp                 |  4 +++-
 .../less_equal_value_valarray.pass.cpp                 |  4 +++-
 .../less_valarray_valarray.pass.cpp                    |  4 +++-
 .../valarray.comparison/less_valarray_value.pass.cpp   |  4 +++-
 .../valarray.comparison/less_value_valarray.pass.cpp   |  4 +++-
 .../not_equal_valarray_valarray.pass.cpp               |  4 +++-
 .../not_equal_valarray_value.pass.cpp                  |  4 +++-
 .../not_equal_value_valarray.pass.cpp                  |  4 +++-
 .../valarray.comparison/or_valarray_valarray.pass.cpp  |  4 +++-
 .../valarray.comparison/or_valarray_value.pass.cpp     |  4 +++-
 .../valarray.comparison/or_value_valarray.pass.cpp     |  4 +++-
 .../valarray.nonmembers/valarray.special/swap.pass.cpp |  4 +++-
 .../valarray.transcend/abs_valarray.pass.cpp           |  4 +++-
 .../valarray.transcend/acos_valarray.pass.cpp          |  4 +++-
 .../valarray.transcend/asin_valarray.pass.cpp          |  4 +++-
 .../atan2_valarray_valarray.pass.cpp                   |  4 +++-
 .../valarray.transcend/atan2_valarray_value.pass.cpp   |  4 +++-
 .../valarray.transcend/atan2_value_valarray.pass.cpp   |  4 +++-
 .../valarray.transcend/atan_valarray.pass.cpp          |  4 +++-
 .../valarray.transcend/cos_valarray.pass.cpp           |  4 +++-
 .../valarray.transcend/cosh_valarray.pass.cpp          |  4 +++-
 .../valarray.transcend/exp_valarray.pass.cpp           |  4 +++-
 .../valarray.transcend/log10_valarray.pass.cpp         |  4 +++-
 .../valarray.transcend/log_valarray.pass.cpp           |  4 +++-
 .../valarray.transcend/pow_valarray_valarray.pass.cpp  |  4 +++-
 .../valarray.transcend/pow_valarray_value.pass.cpp     |  4 +++-
 .../valarray.transcend/pow_value_valarray.pass.cpp     |  4 +++-
 .../valarray.transcend/sin_valarray.pass.cpp           |  4 +++-
 .../valarray.transcend/sinh_valarray.pass.cpp          |  4 +++-
 .../valarray.transcend/sqrt_valarray.pass.cpp          |  4 +++-
 .../valarray.transcend/tan_valarray.pass.cpp           |  4 +++-
 .../valarray.transcend/tanh_valarray.pass.cpp          |  4 +++-
 .../numarray/valarray.range/begin_const.pass.cpp       |  4 +++-
 .../numarray/valarray.range/begin_non_const.pass.cpp   |  4 +++-
 .../numarray/valarray.range/end_const.pass.cpp         |  4 +++-
 .../numarray/valarray.range/end_non_const.pass.cpp     |  4 +++-
 .../numarray/valarray.syn/nothing_to_do.pass.cpp       |  4 +++-
 .../numeric.ops/accumulate/accumulate.pass.cpp         |  4 +++-
 .../numeric.ops/accumulate/accumulate_op.pass.cpp      |  4 +++-
 .../adjacent.difference/adjacent_difference.pass.cpp   |  4 +++-
 .../adjacent_difference_op.pass.cpp                    |  4 +++-
 .../numeric.ops/exclusive.scan/exclusive_scan.pass.cpp |  4 +++-
 .../exclusive.scan/exclusive_scan_init_op.pass.cpp     |  4 +++-
 .../numeric.ops/inclusive.scan/inclusive_scan.pass.cpp |  4 +++-
 .../inclusive.scan/inclusive_scan_op.pass.cpp          |  4 +++-
 .../inclusive.scan/inclusive_scan_op_init.pass.cpp     |  4 +++-
 .../numeric.ops/inner.product/inner_product.pass.cpp   |  4 +++-
 .../inner.product/inner_product_comp.pass.cpp          |  4 +++-
 .../numerics/numeric.ops/numeric.iota/iota.pass.cpp    |  4 +++-
 .../numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp     |  4 +++-
 .../numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp     |  4 +++-
 .../numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp     |  4 +++-
 .../numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp     |  4 +++-
 .../numeric.ops.gcd/gcd.not_integral1.fail.cpp         |  4 +++-
 .../numeric.ops.gcd/gcd.not_integral2.fail.cpp         |  4 +++-
 .../numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp  |  4 +++-
 .../numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp     |  4 +++-
 .../numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp     |  4 +++-
 .../numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp     |  4 +++-
 .../numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp     |  4 +++-
 .../numeric.ops.lcm/lcm.not_integral1.fail.cpp         |  4 +++-
 .../numeric.ops.lcm/lcm.not_integral2.fail.cpp         |  4 +++-
 .../numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp  |  4 +++-
 .../numeric.ops/partial.sum/partial_sum.pass.cpp       |  4 +++-
 .../numeric.ops/partial.sum/partial_sum_op.pass.cpp    |  4 +++-
 test/std/numerics/numeric.ops/reduce/reduce.pass.cpp   |  4 +++-
 .../numerics/numeric.ops/reduce/reduce_init.pass.cpp   |  4 +++-
 .../numeric.ops/reduce/reduce_init_op.pass.cpp         |  4 +++-
 .../transform_exclusive_scan_init_bop_uop.pass.cpp     |  4 +++-
 .../transform_inclusive_scan_bop_uop.pass.cpp          |  4 +++-
 .../transform_inclusive_scan_bop_uop_init.pass.cpp     |  4 +++-
 .../transform_reduce_iter_iter_init_bop_uop.pass.cpp   |  4 +++-
 .../transform_reduce_iter_iter_iter_init.pass.cpp      |  4 +++-
 ...transform_reduce_iter_iter_iter_init_op_op.pass.cpp |  4 +++-
 .../numeric.requirements/nothing_to_do.pass.cpp        |  4 +++-
 .../numerics/numerics.general/nothing_to_do.pass.cpp   |  4 +++-
 test/std/numerics/rand/nothing_to_do.pass.cpp          |  4 +++-
 .../numerics/rand/rand.adapt/nothing_to_do.pass.cpp    |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/assign.pass.cpp    |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/copy.pass.cpp      |  4 +++-
 .../rand.adapt.disc/ctor_engine_copy.pass.cpp          |  4 +++-
 .../rand.adapt.disc/ctor_engine_move.pass.cpp          |  4 +++-
 .../rand.adapt.disc/ctor_result_type.pass.cpp          |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/default.pass.cpp   |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/discard.pass.cpp   |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/eval.pass.cpp      |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/io.pass.cpp        |  4 +++-
 .../rand.adapt/rand.adapt.disc/result_type.pass.cpp    |  4 +++-
 .../rand.adapt.disc/seed_result_type.pass.cpp          |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp |  4 +++-
 .../rand/rand.adapt/rand.adapt.disc/values.pass.cpp    |  4 +++-
 .../rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp   |  4 +++-
 .../rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp     |  4 +++-
 .../rand.adapt.ibits/ctor_engine_copy.pass.cpp         |  4 +++-
 .../rand.adapt.ibits/ctor_engine_move.pass.cpp         |  4 +++-
 .../rand.adapt.ibits/ctor_result_type.pass.cpp         |  4 +++-
 .../rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp     |  4 +++-
 .../rand/rand.adapt/rand.adapt.ibits/default.pass.cpp  |  4 +++-
 .../rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp  |  4 +++-
 .../rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp     |  4 +++-
 .../rand/rand.adapt/rand.adapt.ibits/io.pass.cpp       |  4 +++-
 .../rand.adapt/rand.adapt.ibits/result_type.pass.cpp   |  4 +++-
 .../rand.adapt.ibits/seed_result_type.pass.cpp         |  4 +++-
 .../rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp     |  4 +++-
 .../rand/rand.adapt/rand.adapt.ibits/values.pass.cpp   |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp    |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp      |  4 +++-
 .../rand.adapt.shuf/ctor_engine_copy.pass.cpp          |  4 +++-
 .../rand.adapt.shuf/ctor_engine_move.pass.cpp          |  4 +++-
 .../rand.adapt.shuf/ctor_result_type.pass.cpp          |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/default.pass.cpp   |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp   |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp      |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/io.pass.cpp        |  4 +++-
 .../rand.adapt/rand.adapt.shuf/result_type.pass.cpp    |  4 +++-
 .../rand.adapt.shuf/seed_result_type.pass.cpp          |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp |  4 +++-
 .../rand/rand.adapt/rand.adapt.shuf/values.pass.cpp    |  4 +++-
 test/std/numerics/rand/rand.device/ctor.pass.cpp       |  4 +++-
 test/std/numerics/rand/rand.device/entropy.pass.cpp    |  4 +++-
 test/std/numerics/rand/rand.device/eval.pass.cpp       |  4 +++-
 test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp |  4 +++-
 .../rand.dis/rand.dist.bern/nothing_to_do.pass.cpp     |  4 +++-
 .../rand.dist.bern.bernoulli/assign.pass.cpp           |  4 +++-
 .../rand.dist.bern.bernoulli/copy.pass.cpp             |  4 +++-
 .../rand.dist.bern.bernoulli/ctor_double.pass.cpp      |  4 +++-
 .../rand.dist.bern.bernoulli/ctor_param.pass.cpp       |  4 +++-
 .../rand.dist.bern.bernoulli/eq.pass.cpp               |  4 +++-
 .../rand.dist.bern.bernoulli/eval.pass.cpp             |  4 +++-
 .../rand.dist.bern.bernoulli/eval_param.pass.cpp       |  4 +++-
 .../rand.dist.bern.bernoulli/get_param.pass.cpp        |  4 +++-
 .../rand.dist.bern.bernoulli/io.pass.cpp               |  4 +++-
 .../rand.dist.bern.bernoulli/max.pass.cpp              |  4 +++-
 .../rand.dist.bern.bernoulli/min.pass.cpp              |  4 +++-
 .../rand.dist.bern.bernoulli/param_assign.pass.cpp     |  4 +++-
 .../rand.dist.bern.bernoulli/param_copy.pass.cpp       |  4 +++-
 .../rand.dist.bern.bernoulli/param_ctor.pass.cpp       |  4 +++-
 .../rand.dist.bern.bernoulli/param_eq.pass.cpp         |  4 +++-
 .../rand.dist.bern.bernoulli/param_types.pass.cpp      |  4 +++-
 .../rand.dist.bern.bernoulli/set_param.pass.cpp        |  4 +++-
 .../rand.dist.bern.bernoulli/types.pass.cpp            |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp  |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp    |  4 +++-
 .../rand.dist.bern.bin/ctor_int_double.pass.cpp        |  4 +++-
 .../rand.dist.bern.bin/ctor_param.pass.cpp             |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp      |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp    |  4 +++-
 .../rand.dist.bern.bin/eval_param.pass.cpp             |  4 +++-
 .../rand.dist.bern.bin/get_param.pass.cpp              |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/io.pass.cpp      |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/max.pass.cpp     |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/min.pass.cpp     |  4 +++-
 .../rand.dist.bern.bin/param_assign.pass.cpp           |  4 +++-
 .../rand.dist.bern.bin/param_copy.pass.cpp             |  4 +++-
 .../rand.dist.bern.bin/param_ctor.pass.cpp             |  4 +++-
 .../rand.dist.bern.bin/param_eq.pass.cpp               |  4 +++-
 .../rand.dist.bern.bin/param_types.pass.cpp            |  4 +++-
 .../rand.dist.bern.bin/set_param.pass.cpp              |  4 +++-
 .../rand.dist.bern/rand.dist.bern.bin/types.pass.cpp   |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp  |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp    |  4 +++-
 .../rand.dist.bern.geo/ctor_double.pass.cpp            |  4 +++-
 .../rand.dist.bern.geo/ctor_param.pass.cpp             |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp      |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp    |  4 +++-
 .../rand.dist.bern.geo/eval_param.pass.cpp             |  4 +++-
 .../rand.dist.bern.geo/get_param.pass.cpp              |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/io.pass.cpp      |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/max.pass.cpp     |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/min.pass.cpp     |  4 +++-
 .../rand.dist.bern.geo/param_assign.pass.cpp           |  4 +++-
 .../rand.dist.bern.geo/param_copy.pass.cpp             |  4 +++-
 .../rand.dist.bern.geo/param_ctor.pass.cpp             |  4 +++-
 .../rand.dist.bern.geo/param_eq.pass.cpp               |  4 +++-
 .../rand.dist.bern.geo/param_types.pass.cpp            |  4 +++-
 .../rand.dist.bern.geo/set_param.pass.cpp              |  4 +++-
 .../rand.dist.bern/rand.dist.bern.geo/types.pass.cpp   |  4 +++-
 .../rand.dist.bern.negbin/assign.pass.cpp              |  4 +++-
 .../rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp |  4 +++-
 .../rand.dist.bern.negbin/ctor_int_double.pass.cpp     |  4 +++-
 .../rand.dist.bern.negbin/ctor_param.pass.cpp          |  4 +++-
 .../rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp   |  4 +++-
 .../rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp |  4 +++-
 .../rand.dist.bern.negbin/eval_param.pass.cpp          |  4 +++-
 .../rand.dist.bern.negbin/get_param.pass.cpp           |  4 +++-
 .../rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp   |  4 +++-
 .../rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp  |  4 +++-
 .../rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp  |  4 +++-
 .../rand.dist.bern.negbin/param_assign.pass.cpp        |  4 +++-
 .../rand.dist.bern.negbin/param_copy.pass.cpp          |  4 +++-
 .../rand.dist.bern.negbin/param_ctor.pass.cpp          |  4 +++-
 .../rand.dist.bern.negbin/param_eq.pass.cpp            |  4 +++-
 .../rand.dist.bern.negbin/param_types.pass.cpp         |  4 +++-
 .../rand.dist.bern.negbin/set_param.pass.cpp           |  4 +++-
 .../rand.dist.bern.negbin/types.pass.cpp               |  4 +++-
 .../rand.dis/rand.dist.norm/nothing_to_do.pass.cpp     |  4 +++-
 .../rand.dist.norm.cauchy/assign.pass.cpp              |  4 +++-
 .../rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp |  4 +++-
 .../rand.dist.norm.cauchy/ctor_double_double.pass.cpp  |  4 +++-
 .../rand.dist.norm.cauchy/ctor_param.pass.cpp          |  4 +++-
 .../rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp   |  4 +++-
 .../rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp |  4 +++-
 .../rand.dist.norm.cauchy/eval_param.pass.cpp          |  4 +++-
 .../rand.dist.norm.cauchy/get_param.pass.cpp           |  4 +++-
 .../rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp   |  4 +++-
 .../rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp  |  4 +++-
 .../rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp  |  4 +++-
 .../rand.dist.norm.cauchy/param_assign.pass.cpp        |  4 +++-
 .../rand.dist.norm.cauchy/param_copy.pass.cpp          |  4 +++-
 .../rand.dist.norm.cauchy/param_ctor.pass.cpp          |  4 +++-
 .../rand.dist.norm.cauchy/param_eq.pass.cpp            |  4 +++-
 .../rand.dist.norm.cauchy/param_types.pass.cpp         |  4 +++-
 .../rand.dist.norm.cauchy/set_param.pass.cpp           |  4 +++-
 .../rand.dist.norm.cauchy/types.pass.cpp               |  4 +++-
 .../rand.dist.norm.chisq/assign.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp  |  4 +++-
 .../rand.dist.norm.chisq/ctor_double.pass.cpp          |  4 +++-
 .../rand.dist.norm.chisq/ctor_param.pass.cpp           |  4 +++-
 .../rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp    |  4 +++-
 .../rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp  |  4 +++-
 .../rand.dist.norm.chisq/eval_param.pass.cpp           |  4 +++-
 .../rand.dist.norm.chisq/get_param.pass.cpp            |  4 +++-
 .../rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp    |  4 +++-
 .../rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp   |  4 +++-
 .../rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp   |  4 +++-
 .../rand.dist.norm.chisq/param_assign.pass.cpp         |  4 +++-
 .../rand.dist.norm.chisq/param_copy.pass.cpp           |  4 +++-
 .../rand.dist.norm.chisq/param_ctor.pass.cpp           |  4 +++-
 .../rand.dist.norm.chisq/param_eq.pass.cpp             |  4 +++-
 .../rand.dist.norm.chisq/param_types.pass.cpp          |  4 +++-
 .../rand.dist.norm.chisq/set_param.pass.cpp            |  4 +++-
 .../rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/assign.pass.cpp    |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/copy.pass.cpp      |  4 +++-
 .../rand.dist.norm.f/ctor_double_double.pass.cpp       |  4 +++-
 .../rand.dist.norm.f/ctor_param.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/eq.pass.cpp        |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/eval.pass.cpp      |  4 +++-
 .../rand.dist.norm.f/eval_param.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/io.pass.cpp        |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/max.pass.cpp       |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/min.pass.cpp       |  4 +++-
 .../rand.dist.norm.f/param_assign.pass.cpp             |  4 +++-
 .../rand.dist.norm.f/param_copy.pass.cpp               |  4 +++-
 .../rand.dist.norm.f/param_ctor.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp  |  4 +++-
 .../rand.dist.norm.f/param_types.pass.cpp              |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp |  4 +++-
 .../rand.dist.norm/rand.dist.norm.f/types.pass.cpp     |  4 +++-
 .../rand.dist.norm.lognormal/assign.pass.cpp           |  4 +++-
 .../rand.dist.norm.lognormal/copy.pass.cpp             |  4 +++-
 .../ctor_double_double.pass.cpp                        |  4 +++-
 .../rand.dist.norm.lognormal/ctor_param.pass.cpp       |  4 +++-
 .../rand.dist.norm.lognormal/eq.pass.cpp               |  4 +++-
 .../rand.dist.norm.lognormal/eval.pass.cpp             |  4 +++-
 .../rand.dist.norm.lognormal/eval_param.pass.cpp       |  4 +++-
 .../rand.dist.norm.lognormal/get_param.pass.cpp        |  4 +++-
 .../rand.dist.norm.lognormal/io.pass.cpp               |  4 +++-
 .../rand.dist.norm.lognormal/max.pass.cpp              |  4 +++-
 .../rand.dist.norm.lognormal/min.pass.cpp              |  4 +++-
 .../rand.dist.norm.lognormal/param_assign.pass.cpp     |  4 +++-
 .../rand.dist.norm.lognormal/param_copy.pass.cpp       |  4 +++-
 .../rand.dist.norm.lognormal/param_ctor.pass.cpp       |  4 +++-
 .../rand.dist.norm.lognormal/param_eq.pass.cpp         |  4 +++-
 .../rand.dist.norm.lognormal/param_types.pass.cpp      |  4 +++-
 .../rand.dist.norm.lognormal/set_param.pass.cpp        |  4 +++-
 .../rand.dist.norm.lognormal/types.pass.cpp            |  4 +++-
 .../rand.dist.norm.normal/assign.pass.cpp              |  4 +++-
 .../rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp |  4 +++-
 .../rand.dist.norm.normal/ctor_double_double.pass.cpp  |  4 +++-
 .../rand.dist.norm.normal/ctor_param.pass.cpp          |  4 +++-
 .../rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp   |  4 +++-
 .../rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp |  4 +++-
 .../rand.dist.norm.normal/eval_param.pass.cpp          |  4 +++-
 .../rand.dist.norm.normal/get_param.pass.cpp           |  4 +++-
 .../rand.dist.norm/rand.dist.norm.normal/io.pass.cpp   |  4 +++-
 .../rand.dist.norm/rand.dist.norm.normal/max.pass.cpp  |  4 +++-
 .../rand.dist.norm/rand.dist.norm.normal/min.pass.cpp  |  4 +++-
 .../rand.dist.norm.normal/param_assign.pass.cpp        |  4 +++-
 .../rand.dist.norm.normal/param_copy.pass.cpp          |  4 +++-
 .../rand.dist.norm.normal/param_ctor.pass.cpp          |  4 +++-
 .../rand.dist.norm.normal/param_eq.pass.cpp            |  4 +++-
 .../rand.dist.norm.normal/param_types.pass.cpp         |  4 +++-
 .../rand.dist.norm.normal/set_param.pass.cpp           |  4 +++-
 .../rand.dist.norm.normal/types.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/assign.pass.cpp    |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/copy.pass.cpp      |  4 +++-
 .../rand.dist.norm.t/ctor_double.pass.cpp              |  4 +++-
 .../rand.dist.norm.t/ctor_param.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/eq.pass.cpp        |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/eval.pass.cpp      |  4 +++-
 .../rand.dist.norm.t/eval_param.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/io.pass.cpp        |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/max.pass.cpp       |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/min.pass.cpp       |  4 +++-
 .../rand.dist.norm.t/param_assign.pass.cpp             |  4 +++-
 .../rand.dist.norm.t/param_copy.pass.cpp               |  4 +++-
 .../rand.dist.norm.t/param_ctor.pass.cpp               |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp  |  4 +++-
 .../rand.dist.norm.t/param_types.pass.cpp              |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp |  4 +++-
 .../rand.dist.norm/rand.dist.norm.t/types.pass.cpp     |  4 +++-
 .../rand.dis/rand.dist.pois/nothing_to_do.pass.cpp     |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp  |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp    |  4 +++-
 .../rand.dist.pois.exp/ctor_double.pass.cpp            |  4 +++-
 .../rand.dist.pois.exp/ctor_param.pass.cpp             |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp      |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp    |  4 +++-
 .../rand.dist.pois.exp/eval_param.pass.cpp             |  4 +++-
 .../rand.dist.pois.exp/get_param.pass.cpp              |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/io.pass.cpp      |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/max.pass.cpp     |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/min.pass.cpp     |  4 +++-
 .../rand.dist.pois.exp/param_assign.pass.cpp           |  4 +++-
 .../rand.dist.pois.exp/param_copy.pass.cpp             |  4 +++-
 .../rand.dist.pois.exp/param_ctor.pass.cpp             |  4 +++-
 .../rand.dist.pois.exp/param_eq.pass.cpp               |  4 +++-
 .../rand.dist.pois.exp/param_types.pass.cpp            |  4 +++-
 .../rand.dist.pois.exp/set_param.pass.cpp              |  4 +++-
 .../rand.dist.pois/rand.dist.pois.exp/types.pass.cpp   |  4 +++-
 .../rand.dist.pois.extreme/assign.pass.cpp             |  4 +++-
 .../rand.dist.pois.extreme/copy.pass.cpp               |  4 +++-
 .../rand.dist.pois.extreme/ctor_double_double.pass.cpp |  4 +++-
 .../rand.dist.pois.extreme/ctor_param.pass.cpp         |  4 +++-
 .../rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp  |  4 +++-
 .../rand.dist.pois.extreme/eval.pass.cpp               |  4 +++-
 .../rand.dist.pois.extreme/eval_param.pass.cpp         |  4 +++-
 .../rand.dist.pois.extreme/get_param.pass.cpp          |  4 +++-
 .../rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp  |  4 +++-
 .../rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp |  4 +++-
 .../rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp |  4 +++-
 .../rand.dist.pois.extreme/param_assign.pass.cpp       |  4 +++-
 .../rand.dist.pois.extreme/param_copy.pass.cpp         |  4 +++-
 .../rand.dist.pois.extreme/param_ctor.pass.cpp         |  4 +++-
 .../rand.dist.pois.extreme/param_eq.pass.cpp           |  4 +++-
 .../rand.dist.pois.extreme/param_types.pass.cpp        |  4 +++-
 .../rand.dist.pois.extreme/set_param.pass.cpp          |  4 +++-
 .../rand.dist.pois.extreme/types.pass.cpp              |  4 +++-
 .../rand.dist.pois.gamma/assign.pass.cpp               |  4 +++-
 .../rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp  |  4 +++-
 .../rand.dist.pois.gamma/ctor_double_double.pass.cpp   |  4 +++-
 .../rand.dist.pois.gamma/ctor_param.pass.cpp           |  4 +++-
 .../rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp    |  4 +++-
 .../rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp  |  4 +++-
 .../rand.dist.pois.gamma/eval_param.pass.cpp           |  4 +++-
 .../rand.dist.pois.gamma/get_param.pass.cpp            |  4 +++-
 .../rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp    |  4 +++-
 .../rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp   |  4 +++-
 .../rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp   |  4 +++-
 .../rand.dist.pois.gamma/param_assign.pass.cpp         |  4 +++-
 .../rand.dist.pois.gamma/param_copy.pass.cpp           |  4 +++-
 .../rand.dist.pois.gamma/param_ctor.pass.cpp           |  4 +++-
 .../rand.dist.pois.gamma/param_eq.pass.cpp             |  4 +++-
 .../rand.dist.pois.gamma/param_types.pass.cpp          |  4 +++-
 .../rand.dist.pois.gamma/set_param.pass.cpp            |  4 +++-
 .../rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp |  4 +++-
 .../rand.dist.pois.poisson/assign.pass.cpp             |  4 +++-
 .../rand.dist.pois.poisson/copy.pass.cpp               |  4 +++-
 .../rand.dist.pois.poisson/ctor_double.pass.cpp        |  4 +++-
 .../rand.dist.pois.poisson/ctor_param.pass.cpp         |  4 +++-
 .../rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp  |  4 +++-
 .../rand.dist.pois.poisson/eval.pass.cpp               |  4 +++-
 .../rand.dist.pois.poisson/eval_param.pass.cpp         |  4 +++-
 .../rand.dist.pois.poisson/get_param.pass.cpp          |  4 +++-
 .../rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp  |  4 +++-
 .../rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp |  4 +++-
 .../rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp |  4 +++-
 .../rand.dist.pois.poisson/param_assign.pass.cpp       |  4 +++-
 .../rand.dist.pois.poisson/param_copy.pass.cpp         |  4 +++-
 .../rand.dist.pois.poisson/param_ctor.pass.cpp         |  4 +++-
 .../rand.dist.pois.poisson/param_eq.pass.cpp           |  4 +++-
 .../rand.dist.pois.poisson/param_types.pass.cpp        |  4 +++-
 .../rand.dist.pois.poisson/set_param.pass.cpp          |  4 +++-
 .../rand.dist.pois.poisson/types.pass.cpp              |  4 +++-
 .../rand.dist.pois.weibull/assign.pass.cpp             |  4 +++-
 .../rand.dist.pois.weibull/copy.pass.cpp               |  4 +++-
 .../rand.dist.pois.weibull/ctor_double_double.pass.cpp |  4 +++-
 .../rand.dist.pois.weibull/ctor_param.pass.cpp         |  4 +++-
 .../rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp  |  4 +++-
 .../rand.dist.pois.weibull/eval.pass.cpp               |  4 +++-
 .../rand.dist.pois.weibull/eval_param.pass.cpp         |  4 +++-
 .../rand.dist.pois.weibull/get_param.pass.cpp          |  4 +++-
 .../rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp  |  4 +++-
 .../rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp |  4 +++-
 .../rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp |  4 +++-
 .../rand.dist.pois.weibull/param_assign.pass.cpp       |  4 +++-
 .../rand.dist.pois.weibull/param_copy.pass.cpp         |  4 +++-
 .../rand.dist.pois.weibull/param_ctor.pass.cpp         |  4 +++-
 .../rand.dist.pois.weibull/param_eq.pass.cpp           |  4 +++-
 .../rand.dist.pois.weibull/param_types.pass.cpp        |  4 +++-
 .../rand.dist.pois.weibull/set_param.pass.cpp          |  4 +++-
 .../rand.dist.pois.weibull/types.pass.cpp              |  4 +++-
 .../rand.dis/rand.dist.samp/nothing_to_do.pass.cpp     |  4 +++-
 .../rand.dist.samp.discrete/assign.pass.cpp            |  4 +++-
 .../rand.dist.samp.discrete/copy.pass.cpp              |  4 +++-
 .../rand.dist.samp.discrete/ctor_default.pass.cpp      |  4 +++-
 .../rand.dist.samp.discrete/ctor_func.pass.cpp         |  4 +++-
 .../rand.dist.samp.discrete/ctor_init.pass.cpp         |  4 +++-
 .../rand.dist.samp.discrete/ctor_iterator.pass.cpp     |  4 +++-
 .../rand.dist.samp.discrete/ctor_param.pass.cpp        |  4 +++-
 .../rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp |  4 +++-
 .../rand.dist.samp.discrete/eval.pass.cpp              |  4 +++-
 .../rand.dist.samp.discrete/eval_param.pass.cpp        |  4 +++-
 .../rand.dist.samp.discrete/get_param.pass.cpp         |  4 +++-
 .../rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp |  4 +++-
 .../rand.dist.samp.discrete/max.pass.cpp               |  4 +++-
 .../rand.dist.samp.discrete/min.pass.cpp               |  4 +++-
 .../rand.dist.samp.discrete/param_assign.pass.cpp      |  4 +++-
 .../rand.dist.samp.discrete/param_copy.pass.cpp        |  4 +++-
 .../param_ctor_default.pass.cpp                        |  4 +++-
 .../rand.dist.samp.discrete/param_ctor_func.pass.cpp   |  4 +++-
 .../rand.dist.samp.discrete/param_ctor_init.pass.cpp   |  4 +++-
 .../param_ctor_iterator.pass.cpp                       |  4 +++-
 .../rand.dist.samp.discrete/param_eq.pass.cpp          |  4 +++-
 .../rand.dist.samp.discrete/param_types.pass.cpp       |  4 +++-
 .../rand.dist.samp.discrete/set_param.pass.cpp         |  4 +++-
 .../rand.dist.samp.discrete/types.pass.cpp             |  4 +++-
 .../rand.dist.samp.pconst/assign.pass.cpp              |  4 +++-
 .../rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp |  4 +++-
 .../rand.dist.samp.pconst/ctor_default.pass.cpp        |  4 +++-
 .../rand.dist.samp.pconst/ctor_func.pass.cpp           |  4 +++-
 .../rand.dist.samp.pconst/ctor_init_func.pass.cpp      |  4 +++-
 .../rand.dist.samp.pconst/ctor_iterator.pass.cpp       |  4 +++-
 .../rand.dist.samp.pconst/ctor_param.pass.cpp          |  4 +++-
 .../rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp   |  4 +++-
 .../rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp |  4 +++-
 .../rand.dist.samp.pconst/eval_param.pass.cpp          |  4 +++-
 .../rand.dist.samp.pconst/get_param.pass.cpp           |  4 +++-
 .../rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp   |  4 +++-
 .../rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp  |  4 +++-
 .../rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp  |  4 +++-
 .../rand.dist.samp.pconst/param_assign.pass.cpp        |  4 +++-
 .../rand.dist.samp.pconst/param_copy.pass.cpp          |  4 +++-
 .../rand.dist.samp.pconst/param_ctor_default.pass.cpp  |  4 +++-
 .../rand.dist.samp.pconst/param_ctor_func.pass.cpp     |  4 +++-
 .../param_ctor_init_func.pass.cpp                      |  4 +++-
 .../rand.dist.samp.pconst/param_ctor_iterator.pass.cpp |  4 +++-
 .../rand.dist.samp.pconst/param_eq.pass.cpp            |  4 +++-
 .../rand.dist.samp.pconst/param_types.pass.cpp         |  4 +++-
 .../rand.dist.samp.pconst/set_param.pass.cpp           |  4 +++-
 .../rand.dist.samp.pconst/types.pass.cpp               |  4 +++-
 .../rand.dist.samp.plinear/assign.pass.cpp             |  4 +++-
 .../rand.dist.samp.plinear/copy.pass.cpp               |  4 +++-
 .../rand.dist.samp.plinear/ctor_default.pass.cpp       |  4 +++-
 .../rand.dist.samp.plinear/ctor_func.pass.cpp          |  4 +++-
 .../rand.dist.samp.plinear/ctor_init_func.pass.cpp     |  4 +++-
 .../rand.dist.samp.plinear/ctor_iterator.pass.cpp      |  4 +++-
 .../rand.dist.samp.plinear/ctor_param.pass.cpp         |  4 +++-
 .../rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp  |  4 +++-
 .../rand.dist.samp.plinear/eval.pass.cpp               |  4 +++-
 .../rand.dist.samp.plinear/eval_param.pass.cpp         |  4 +++-
 .../rand.dist.samp.plinear/get_param.pass.cpp          |  4 +++-
 .../rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp  |  4 +++-
 .../rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp |  4 +++-
 .../rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp |  4 +++-
 .../rand.dist.samp.plinear/param_assign.pass.cpp       |  4 +++-
 .../rand.dist.samp.plinear/param_copy.pass.cpp         |  4 +++-
 .../rand.dist.samp.plinear/param_ctor_default.pass.cpp |  4 +++-
 .../rand.dist.samp.plinear/param_ctor_func.pass.cpp    |  4 +++-
 .../param_ctor_init_func.pass.cpp                      |  4 +++-
 .../param_ctor_iterator.pass.cpp                       |  4 +++-
 .../rand.dist.samp.plinear/param_eq.pass.cpp           |  4 +++-
 .../rand.dist.samp.plinear/param_types.pass.cpp        |  4 +++-
 .../rand.dist.samp.plinear/set_param.pass.cpp          |  4 +++-
 .../rand.dist.samp.plinear/types.pass.cpp              |  4 +++-
 .../rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/assign.pass.cpp    |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/copy.pass.cpp      |  4 +++-
 .../rand.dist.uni.int/ctor_int_int.pass.cpp            |  4 +++-
 .../rand.dist.uni.int/ctor_param.pass.cpp              |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/eq.pass.cpp        |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/eval.pass.cpp      |  4 +++-
 .../rand.dist.uni.int/eval_param.pass.cpp              |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/io.pass.cpp        |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/max.pass.cpp       |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/min.pass.cpp       |  4 +++-
 .../rand.dist.uni.int/param_assign.pass.cpp            |  4 +++-
 .../rand.dist.uni.int/param_copy.pass.cpp              |  4 +++-
 .../rand.dist.uni.int/param_ctor.pass.cpp              |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp  |  4 +++-
 .../rand.dist.uni.int/param_types.pass.cpp             |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp |  4 +++-
 .../rand.dist.uni/rand.dist.uni.int/types.pass.cpp     |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/assign.pass.cpp   |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/copy.pass.cpp     |  4 +++-
 .../rand.dist.uni.real/ctor_int_int.pass.cpp           |  4 +++-
 .../rand.dist.uni.real/ctor_param.pass.cpp             |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/eq.pass.cpp       |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/eval.pass.cpp     |  4 +++-
 .../rand.dist.uni.real/eval_param.pass.cpp             |  4 +++-
 .../rand.dist.uni.real/get_param.pass.cpp              |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/io.pass.cpp       |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/max.pass.cpp      |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/min.pass.cpp      |  4 +++-
 .../rand.dist.uni.real/param_assign.pass.cpp           |  4 +++-
 .../rand.dist.uni.real/param_copy.pass.cpp             |  4 +++-
 .../rand.dist.uni.real/param_ctor.pass.cpp             |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp |  4 +++-
 .../rand.dist.uni.real/param_types.pass.cpp            |  4 +++-
 .../rand.dist.uni.real/set_param.pass.cpp              |  4 +++-
 .../rand.dist.uni/rand.dist.uni.real/types.pass.cpp    |  4 +++-
 test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/assign.pass.cpp       |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/copy.pass.cpp         |  4 +++-
 .../rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp  |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp    |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/default.pass.cpp      |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/discard.pass.cpp      |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/eval.pass.cpp         |  4 +++-
 .../numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp  |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/result_type.pass.cpp  |  4 +++-
 .../rand.eng/rand.eng.lcong/seed_result_type.pass.cpp  |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp    |  4 +++-
 .../rand/rand.eng/rand.eng.lcong/values.pass.cpp       |  4 +++-
 .../rand/rand.eng/rand.eng.mers/assign.pass.cpp        |  4 +++-
 .../numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp |  4 +++-
 .../rand.eng/rand.eng.mers/ctor_result_type.pass.cpp   |  4 +++-
 .../rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp     |  4 +++-
 .../rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp |  4 +++-
 .../rand/rand.eng/rand.eng.mers/default.pass.cpp       |  4 +++-
 .../rand/rand.eng/rand.eng.mers/discard.pass.cpp       |  4 +++-
 .../numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp |  4 +++-
 .../numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp   |  4 +++-
 .../rand/rand.eng/rand.eng.mers/result_type.pass.cpp   |  4 +++-
 .../rand.eng/rand.eng.mers/seed_result_type.pass.cpp   |  4 +++-
 .../rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp     |  4 +++-
 .../rand/rand.eng/rand.eng.mers/values.pass.cpp        |  4 +++-
 .../rand/rand.eng/rand.eng.sub/assign.pass.cpp         |  4 +++-
 .../numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp  |  4 +++-
 .../rand.eng/rand.eng.sub/ctor_result_type.pass.cpp    |  4 +++-
 .../rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp      |  4 +++-
 .../rand/rand.eng/rand.eng.sub/default.pass.cpp        |  4 +++-
 .../rand/rand.eng/rand.eng.sub/discard.pass.cpp        |  4 +++-
 .../numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp  |  4 +++-
 .../numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp    |  4 +++-
 .../rand/rand.eng/rand.eng.sub/result_type.pass.cpp    |  4 +++-
 .../rand.eng/rand.eng.sub/seed_result_type.pass.cpp    |  4 +++-
 .../rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp      |  4 +++-
 .../rand/rand.eng/rand.eng.sub/values.pass.cpp         |  4 +++-
 .../rand/rand.predef/default_random_engine.pass.cpp    |  4 +++-
 test/std/numerics/rand/rand.predef/knuth_b.pass.cpp    |  4 +++-
 .../std/numerics/rand/rand.predef/minstd_rand.pass.cpp |  4 +++-
 .../numerics/rand/rand.predef/minstd_rand0.pass.cpp    |  4 +++-
 test/std/numerics/rand/rand.predef/mt19937.pass.cpp    |  4 +++-
 test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp |  4 +++-
 test/std/numerics/rand/rand.predef/ranlux24.pass.cpp   |  4 +++-
 .../numerics/rand/rand.predef/ranlux24_base.pass.cpp   |  4 +++-
 test/std/numerics/rand/rand.predef/ranlux48.pass.cpp   |  4 +++-
 .../numerics/rand/rand.predef/ranlux48_base.pass.cpp   |  4 +++-
 test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp |  4 +++-
 .../rand.req/rand.req.adapt/nothing_to_do.pass.cpp     |  4 +++-
 .../rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp  |  4 +++-
 .../rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp  |  4 +++-
 .../rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp |  4 +++-
 .../rand.req/rand.req.seedseq/nothing_to_do.pass.cpp   |  4 +++-
 .../rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp |  4 +++-
 .../std/numerics/rand/rand.util/nothing_to_do.pass.cpp |  4 +++-
 .../rand.util.canonical/generate_canonical.pass.cpp    |  4 +++-
 .../rand/rand.util/rand.util.seedseq/assign.fail.cpp   |  4 +++-
 .../rand/rand.util/rand.util.seedseq/copy.fail.cpp     |  4 +++-
 .../rand/rand.util/rand.util.seedseq/default.pass.cpp  |  4 +++-
 .../rand/rand.util/rand.util.seedseq/generate.pass.cpp |  4 +++-
 .../rand.util.seedseq/initializer_list.pass.cpp        |  4 +++-
 .../rand/rand.util/rand.util.seedseq/iterator.pass.cpp |  4 +++-
 .../rand/rand.util/rand.util.seedseq/types.pass.cpp    |  4 +++-
 test/std/re/nothing_to_do.pass.cpp                     |  4 +++-
 test/std/re/re.alg/nothing_to_do.pass.cpp              |  4 +++-
 test/std/re/re.alg/re.alg.match/awk.pass.cpp           |  3 ++-
 test/std/re/re.alg/re.alg.match/basic.fail.cpp         |  4 +++-
 test/std/re/re.alg/re.alg.match/basic.pass.cpp         |  4 +++-
 test/std/re/re.alg/re.alg.match/ecma.pass.cpp          |  4 +++-
 test/std/re/re.alg/re.alg.match/egrep.pass.cpp         |  4 +++-
 test/std/re/re.alg/re.alg.match/exponential.pass.cpp   |  2 +-
 test/std/re/re.alg/re.alg.match/extended.pass.cpp      |  4 +++-
 test/std/re/re.alg/re.alg.match/grep.pass.cpp          |  4 +++-
 .../re.alg.match/inverted_character_classes.pass.cpp   |  4 +++-
 .../re/re.alg/re.alg.match/lookahead_capture.pass.cpp  |  4 +++-
 .../re.alg/re.alg.match/parse_curly_brackets.pass.cpp  |  4 +++-
 test/std/re/re.alg/re.alg.replace/exponential.pass.cpp |  3 ++-
 test/std/re/re.alg/re.alg.replace/test1.pass.cpp       |  4 +++-
 test/std/re/re.alg/re.alg.replace/test2.pass.cpp       |  4 +++-
 test/std/re/re.alg/re.alg.replace/test3.pass.cpp       |  4 +++-
 test/std/re/re.alg/re.alg.replace/test4.pass.cpp       |  4 +++-
 test/std/re/re.alg/re.alg.replace/test5.pass.cpp       |  4 +++-
 test/std/re/re.alg/re.alg.replace/test6.pass.cpp       |  4 +++-
 test/std/re/re.alg/re.alg.search/awk.pass.cpp          |  4 +++-
 test/std/re/re.alg/re.alg.search/backup.pass.cpp       |  4 +++-
 test/std/re/re.alg/re.alg.search/basic.fail.cpp        |  4 +++-
 test/std/re/re.alg/re.alg.search/basic.pass.cpp        |  4 +++-
 test/std/re/re.alg/re.alg.search/ecma.pass.cpp         |  4 +++-
 test/std/re/re.alg/re.alg.search/egrep.pass.cpp        |  4 +++-
 test/std/re/re.alg/re.alg.search/exponential.pass.cpp  |  2 +-
 test/std/re/re.alg/re.alg.search/extended.pass.cpp     |  4 +++-
 test/std/re/re.alg/re.alg.search/grep.pass.cpp         |  4 +++-
 .../re.alg.search/invert_neg_word_search.pass.cpp      |  2 +-
 test/std/re/re.alg/re.alg.search/lookahead.pass.cpp    |  4 +++-
 .../std/re/re.alg/re.alg.search/no_update_pos.pass.cpp |  4 +++-
 test/std/re/re.alg/re.except/nothing_to_do.pass.cpp    |  4 +++-
 test/std/re/re.badexp/regex_error.pass.cpp             |  4 +++-
 test/std/re/re.const/nothing_to_do.pass.cpp            |  4 +++-
 test/std/re/re.const/re.err/error_type.pass.cpp        |  4 +++-
 .../re/re.const/re.matchflag/match_flag_type.pass.cpp  |  4 +++-
 .../re/re.const/re.matchflag/match_not_bol.pass.cpp    |  4 +++-
 .../re/re.const/re.matchflag/match_not_eol.pass.cpp    |  4 +++-
 .../re/re.const/re.matchflag/match_not_null.pass.cpp   |  2 +-
 .../re/re.const/re.synopt/syntax_option_type.pass.cpp  |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../re.def/defns.regex.matched/nothing_to_do.pass.cpp  |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../defns.regex.subexpression/nothing_to_do.pass.cpp   |  4 +++-
 test/std/re/re.def/nothing_to_do.pass.cpp              |  4 +++-
 test/std/re/re.general/nothing_to_do.pass.cpp          |  4 +++-
 test/std/re/re.grammar/excessive_brace_count.pass.cpp  |  2 +-
 test/std/re/re.grammar/nothing_to_do.pass.cpp          |  4 +++-
 test/std/re/re.iter/nothing_to_do.pass.cpp             |  4 +++-
 .../re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp |  4 +++-
 .../re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp |  4 +++-
 .../re.regiter/re.regiter.cnstr/default.pass.cpp       |  4 +++-
 .../re.regiter.comp/tested_elsewhere.pass.cpp          |  4 +++-
 .../re.iter/re.regiter/re.regiter.deref/deref.pass.cpp |  4 +++-
 .../re.iter/re.regiter/re.regiter.incr/post.pass.cpp   |  4 +++-
 test/std/re/re.iter/re.regiter/types.pass.cpp          |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp |  4 +++-
 .../re.tokiter/re.tokiter.cnstr/default.pass.cpp       |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp  |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp  |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp   |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp   |  4 +++-
 .../re.tokiter/re.tokiter.cnstr/vector.fail.cpp        |  4 +++-
 .../re.tokiter/re.tokiter.cnstr/vector.pass.cpp        |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp  |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp |  4 +++-
 .../re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp   |  4 +++-
 test/std/re/re.iter/re.tokiter/types.pass.cpp          |  4 +++-
 .../std/re/re.regex/re.regex.assign/assign.il.pass.cpp |  4 +++-
 test/std/re/re.regex/re.regex.assign/assign.pass.cpp   |  4 +++-
 .../re.regex.assign/assign_iter_iter_flag.pass.cpp     |  4 +++-
 .../re.regex/re.regex.assign/assign_ptr_flag.pass.cpp  |  4 +++-
 .../re.regex.assign/assign_ptr_size_flag.pass.cpp      |  4 +++-
 .../re.regex.assign/assign_string_flag.pass.cpp        |  4 +++-
 test/std/re/re.regex/re.regex.assign/copy.pass.cpp     |  4 +++-
 test/std/re/re.regex/re.regex.assign/il.pass.cpp       |  4 +++-
 test/std/re/re.regex/re.regex.assign/ptr.pass.cpp      |  4 +++-
 test/std/re/re.regex/re.regex.assign/string.pass.cpp   |  4 +++-
 test/std/re/re.regex/re.regex.const/constants.pass.cpp |  4 +++-
 .../re/re.regex/re.regex.construct/awk_oct.pass.cpp    |  4 +++-
 .../re.regex/re.regex.construct/bad_backref.pass.cpp   |  4 +++-
 .../re/re.regex/re.regex.construct/bad_ctype.pass.cpp  |  4 +++-
 .../re/re.regex/re.regex.construct/bad_escape.pass.cpp |  4 +++-
 .../re/re.regex/re.regex.construct/bad_repeat.pass.cpp |  4 +++-
 test/std/re/re.regex/re.regex.construct/copy.pass.cpp  |  4 +++-
 .../std/re/re.regex/re.regex.construct/deduct.fail.cpp |  4 +++-
 .../std/re/re.regex/re.regex.construct/deduct.pass.cpp |  4 +++-
 .../re/re.regex/re.regex.construct/default.pass.cpp    |  4 +++-
 .../std/re/re.regex/re.regex.construct/il_flg.pass.cpp |  4 +++-
 .../re/re.regex/re.regex.construct/iter_iter.pass.cpp  |  4 +++-
 .../re.regex/re.regex.construct/iter_iter_flg.pass.cpp |  4 +++-
 test/std/re/re.regex/re.regex.construct/ptr.pass.cpp   |  4 +++-
 .../re/re.regex/re.regex.construct/ptr_flg.pass.cpp    |  4 +++-
 .../re/re.regex/re.regex.construct/ptr_size.pass.cpp   |  4 +++-
 .../re.regex/re.regex.construct/ptr_size_flg.pass.cpp  |  4 +++-
 .../std/re/re.regex/re.regex.construct/string.pass.cpp |  4 +++-
 .../re/re.regex/re.regex.construct/string_flg.pass.cpp |  4 +++-
 test/std/re/re.regex/re.regex.locale/imbue.pass.cpp    |  4 +++-
 .../re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp   |  4 +++-
 .../re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp     |  4 +++-
 .../re.regex.operations/tested_elsewhere.pass.cpp      |  4 +++-
 test/std/re/re.regex/re.regex.swap/swap.pass.cpp       |  4 +++-
 test/std/re/re.regex/types.pass.cpp                    |  4 +++-
 test/std/re/re.req/nothing_to_do.pass.cpp              |  4 +++-
 .../re/re.results/re.results.acc/begin_end.pass.cpp    |  4 +++-
 .../re/re.results/re.results.acc/cbegin_cend.pass.cpp  |  4 +++-
 test/std/re/re.results/re.results.acc/index.pass.cpp   |  4 +++-
 test/std/re/re.results/re.results.acc/length.pass.cpp  |  4 +++-
 .../std/re/re.results/re.results.acc/position.pass.cpp |  4 +++-
 test/std/re/re.results/re.results.acc/prefix.pass.cpp  |  4 +++-
 test/std/re/re.results/re.results.acc/str.pass.cpp     |  4 +++-
 test/std/re/re.results/re.results.acc/suffix.pass.cpp  |  4 +++-
 .../re.results/re.results.all/get_allocator.pass.cpp   |  4 +++-
 .../re/re.results/re.results.const/allocator.pass.cpp  |  4 +++-
 test/std/re/re.results/re.results.const/copy.pass.cpp  |  4 +++-
 .../re.results/re.results.const/copy_assign.pass.cpp   |  4 +++-
 .../re/re.results/re.results.const/default.pass.cpp    |  4 +++-
 test/std/re/re.results/re.results.const/move.pass.cpp  |  4 +++-
 .../re.results/re.results.const/move_assign.pass.cpp   |  4 +++-
 test/std/re/re.results/re.results.form/form1.pass.cpp  |  4 +++-
 test/std/re/re.results/re.results.form/form2.pass.cpp  |  4 +++-
 test/std/re/re.results/re.results.form/form3.pass.cpp  |  4 +++-
 test/std/re/re.results/re.results.form/form4.pass.cpp  |  4 +++-
 .../re/re.results/re.results.nonmember/equal.pass.cpp  |  4 +++-
 test/std/re/re.results/re.results.size/empty.fail.cpp  |  4 +++-
 test/std/re/re.results/re.results.size/empty.pass.cpp  |  4 +++-
 .../re/re.results/re.results.size/max_size.pass.cpp    |  4 +++-
 test/std/re/re.results/re.results.state/ready.pass.cpp |  4 +++-
 .../re/re.results/re.results.swap/member_swap.pass.cpp |  4 +++-
 .../re.results.swap/non_member_swap.pass.cpp           |  4 +++-
 test/std/re/re.results/types.pass.cpp                  |  4 +++-
 .../re.submatch.members/compare_string_type.pass.cpp   |  4 +++-
 .../re.submatch.members/compare_sub_match.pass.cpp     |  4 +++-
 .../compare_value_type_ptr.pass.cpp                    |  4 +++-
 .../re.submatch/re.submatch.members/default.pass.cpp   |  4 +++-
 .../re/re.submatch/re.submatch.members/length.pass.cpp |  4 +++-
 .../re.submatch.members/operator_string.pass.cpp       |  4 +++-
 .../re/re.submatch/re.submatch.members/str.pass.cpp    |  4 +++-
 .../std/re/re.submatch/re.submatch.op/compare.pass.cpp |  4 +++-
 test/std/re/re.submatch/re.submatch.op/stream.pass.cpp |  4 +++-
 test/std/re/re.submatch/types.pass.cpp                 |  4 +++-
 test/std/re/re.syn/cmatch.pass.cpp                     |  4 +++-
 test/std/re/re.syn/cregex_iterator.pass.cpp            |  4 +++-
 test/std/re/re.syn/cregex_token_iterator.pass.cpp      |  4 +++-
 test/std/re/re.syn/csub_match.pass.cpp                 |  4 +++-
 test/std/re/re.syn/regex.pass.cpp                      |  4 +++-
 test/std/re/re.syn/smatch.pass.cpp                     |  4 +++-
 test/std/re/re.syn/sregex_iterator.pass.cpp            |  4 +++-
 test/std/re/re.syn/sregex_token_iterator.pass.cpp      |  4 +++-
 test/std/re/re.syn/ssub_match.pass.cpp                 |  4 +++-
 test/std/re/re.syn/wcmatch.pass.cpp                    |  4 +++-
 test/std/re/re.syn/wcregex_iterator.pass.cpp           |  4 +++-
 test/std/re/re.syn/wcregex_token_iterator.pass.cpp     |  4 +++-
 test/std/re/re.syn/wcsub_match.pass.cpp                |  4 +++-
 test/std/re/re.syn/wregex.pass.cpp                     |  4 +++-
 test/std/re/re.syn/wsmatch.pass.cpp                    |  4 +++-
 test/std/re/re.syn/wsregex_iterator.pass.cpp           |  4 +++-
 test/std/re/re.syn/wsregex_token_iterator.pass.cpp     |  4 +++-
 test/std/re/re.syn/wssub_match.pass.cpp                |  4 +++-
 test/std/re/re.traits/default.pass.cpp                 |  4 +++-
 test/std/re/re.traits/getloc.pass.cpp                  |  4 +++-
 test/std/re/re.traits/imbue.pass.cpp                   |  4 +++-
 test/std/re/re.traits/isctype.pass.cpp                 |  4 +++-
 test/std/re/re.traits/length.pass.cpp                  |  4 +++-
 test/std/re/re.traits/lookup_classname.pass.cpp        |  4 +++-
 test/std/re/re.traits/lookup_collatename.pass.cpp      |  4 +++-
 test/std/re/re.traits/transform.pass.cpp               |  4 +++-
 test/std/re/re.traits/transform_primary.pass.cpp       |  4 +++-
 test/std/re/re.traits/translate.pass.cpp               |  4 +++-
 test/std/re/re.traits/translate_nocase.pass.cpp        |  4 +++-
 test/std/re/re.traits/types.pass.cpp                   |  4 +++-
 test/std/re/re.traits/value.pass.cpp                   |  4 +++-
 .../strings/basic.string.hash/enabled_hashes.pass.cpp  |  4 +++-
 test/std/strings/basic.string.hash/strings.pass.cpp    |  4 +++-
 .../std/strings/basic.string.literals/literal.pass.cpp |  4 +++-
 .../strings/basic.string.literals/literal1.fail.cpp    |  4 +++-
 .../strings/basic.string.literals/literal1.pass.cpp    |  4 +++-
 .../strings/basic.string.literals/literal2.fail.cpp    |  4 +++-
 .../strings/basic.string.literals/literal2.pass.cpp    |  4 +++-
 .../strings/basic.string.literals/literal3.pass.cpp    |  4 +++-
 .../strings/basic.string/allocator_mismatch.fail.cpp   |  4 +++-
 test/std/strings/basic.string/char.bad.fail.cpp        |  4 +++-
 .../std/strings/basic.string/string.access/at.pass.cpp |  4 +++-
 .../strings/basic.string/string.access/back.pass.cpp   |  4 +++-
 .../basic.string/string.access/db_back.pass.cpp        |  6 ++++--
 .../basic.string/string.access/db_cback.pass.cpp       |  6 ++++--
 .../basic.string/string.access/db_cfront.pass.cpp      |  6 ++++--
 .../basic.string/string.access/db_cindex.pass.cpp      |  6 ++++--
 .../basic.string/string.access/db_front.pass.cpp       |  6 ++++--
 .../basic.string/string.access/db_index.pass.cpp       |  6 ++++--
 .../strings/basic.string/string.access/front.pass.cpp  |  4 +++-
 .../strings/basic.string/string.access/index.pass.cpp  |  4 +++-
 .../basic.string/string.capacity/capacity.pass.cpp     |  4 +++-
 .../basic.string/string.capacity/clear.pass.cpp        |  4 +++-
 .../basic.string/string.capacity/empty.fail.cpp        |  4 +++-
 .../basic.string/string.capacity/empty.pass.cpp        |  4 +++-
 .../basic.string/string.capacity/length.pass.cpp       |  4 +++-
 .../basic.string/string.capacity/max_size.pass.cpp     |  4 +++-
 .../string.capacity/over_max_size.pass.cpp             |  4 +++-
 .../basic.string/string.capacity/reserve.pass.cpp      |  4 +++-
 .../basic.string/string.capacity/resize_size.pass.cpp  |  4 +++-
 .../string.capacity/resize_size_char.pass.cpp          |  4 +++-
 .../string.capacity/shrink_to_fit.pass.cpp             |  4 +++-
 .../strings/basic.string/string.capacity/size.pass.cpp |  4 +++-
 .../basic.string/string.cons/T_size_size.pass.cpp      |  4 +++-
 .../strings/basic.string/string.cons/alloc.pass.cpp    |  4 +++-
 .../basic.string/string.cons/brace_assignment.pass.cpp |  4 +++-
 .../basic.string/string.cons/char_assignment.pass.cpp  |  4 +++-
 .../std/strings/basic.string/string.cons/copy.pass.cpp |  4 +++-
 .../basic.string/string.cons/copy_alloc.pass.cpp       |  4 +++-
 .../basic.string/string.cons/copy_assignment.pass.cpp  |  4 +++-
 .../basic.string/string.cons/default_noexcept.pass.cpp |  4 +++-
 .../basic.string/string.cons/dtor_noexcept.pass.cpp    |  4 +++-
 .../string.cons/implicit_deduction_guides.pass.cpp     |  4 +++-
 .../basic.string/string.cons/initializer_list.pass.cpp |  4 +++-
 .../string.cons/initializer_list_assignment.pass.cpp   |  4 +++-
 .../basic.string/string.cons/iter_alloc.pass.cpp       |  4 +++-
 .../string.cons/iter_alloc_deduction.fail.cpp          |  4 +++-
 .../string.cons/iter_alloc_deduction.pass.cpp          |  4 +++-
 .../std/strings/basic.string/string.cons/move.pass.cpp |  4 +++-
 .../basic.string/string.cons/move_alloc.pass.cpp       |  4 +++-
 .../string.cons/move_assign_noexcept.pass.cpp          |  4 +++-
 .../basic.string/string.cons/move_assignment.pass.cpp  |  4 +++-
 .../basic.string/string.cons/move_noexcept.pass.cpp    |  4 +++-
 .../basic.string/string.cons/pointer_alloc.pass.cpp    |  4 +++-
 .../string.cons/pointer_assignment.pass.cpp            |  4 +++-
 .../string.cons/pointer_size_alloc.pass.cpp            |  4 +++-
 .../basic.string/string.cons/size_char_alloc.pass.cpp  |  4 +++-
 .../basic.string/string.cons/string_view.fail.cpp      |  4 +++-
 .../basic.string/string.cons/string_view.pass.cpp      |  4 +++-
 .../string.cons/string_view_assignment.pass.cpp        |  4 +++-
 .../string.cons/string_view_deduction.fail.cpp         |  4 +++-
 .../string.cons/string_view_deduction.pass.cpp         |  4 +++-
 .../string_view_size_size_deduction.fail.cpp           |  4 +++-
 .../string_view_size_size_deduction.pass.cpp           |  4 +++-
 .../strings/basic.string/string.cons/substr.pass.cpp   |  4 +++-
 .../string.ends_with/ends_with.char.pass.cpp           |  4 +++-
 .../string.ends_with/ends_with.ptr.pass.cpp            |  4 +++-
 .../string.ends_with/ends_with.string_view.pass.cpp    |  4 +++-
 .../basic.string/string.iterators/begin.pass.cpp       |  4 +++-
 .../basic.string/string.iterators/cbegin.pass.cpp      |  4 +++-
 .../basic.string/string.iterators/cend.pass.cpp        |  4 +++-
 .../basic.string/string.iterators/crbegin.pass.cpp     |  4 +++-
 .../basic.string/string.iterators/crend.pass.cpp       |  4 +++-
 .../string.iterators/db_iterators_2.pass.cpp           |  6 ++++--
 .../string.iterators/db_iterators_3.pass.cpp           |  6 ++++--
 .../string.iterators/db_iterators_4.pass.cpp           |  6 ++++--
 .../string.iterators/db_iterators_5.pass.cpp           |  6 ++++--
 .../string.iterators/db_iterators_6.pass.cpp           |  6 ++++--
 .../string.iterators/db_iterators_7.pass.cpp           |  6 ++++--
 .../string.iterators/db_iterators_8.pass.cpp           |  6 ++++--
 .../strings/basic.string/string.iterators/end.pass.cpp |  4 +++-
 .../basic.string/string.iterators/iterators.pass.cpp   |  4 +++-
 .../basic.string/string.iterators/rbegin.pass.cpp      |  4 +++-
 .../basic.string/string.iterators/rend.pass.cpp        |  4 +++-
 .../string.modifiers/nothing_to_do.pass.cpp            |  4 +++-
 .../string_append/T_size_size.pass.cpp                 |  4 +++-
 .../string_append/initializer_list.pass.cpp            |  4 +++-
 .../string.modifiers/string_append/iterator.pass.cpp   |  4 +++-
 .../string.modifiers/string_append/pointer.pass.cpp    |  4 +++-
 .../string_append/pointer_size.pass.cpp                |  4 +++-
 .../string.modifiers/string_append/push_back.pass.cpp  |  4 +++-
 .../string.modifiers/string_append/size_char.pass.cpp  |  4 +++-
 .../string.modifiers/string_append/string.pass.cpp     |  4 +++-
 .../string_append/string_size_size.pass.cpp            |  4 +++-
 .../string_append/string_view.pass.cpp                 |  4 +++-
 .../string_assign/T_size_size.pass.cpp                 |  4 +++-
 .../string_assign/initializer_list.pass.cpp            |  4 +++-
 .../string.modifiers/string_assign/iterator.pass.cpp   |  4 +++-
 .../string.modifiers/string_assign/pointer.pass.cpp    |  4 +++-
 .../string_assign/pointer_size.pass.cpp                |  4 +++-
 .../string.modifiers/string_assign/rv_string.pass.cpp  |  4 +++-
 .../string.modifiers/string_assign/size_char.pass.cpp  |  4 +++-
 .../string.modifiers/string_assign/string.pass.cpp     |  4 +++-
 .../string_assign/string_size_size.pass.cpp            |  4 +++-
 .../string_assign/string_view.pass.cpp                 |  4 +++-
 .../string.modifiers/string_copy/copy.pass.cpp         |  4 +++-
 .../string.modifiers/string_erase/iter.pass.cpp        |  4 +++-
 .../string.modifiers/string_erase/iter_iter.pass.cpp   |  4 +++-
 .../string.modifiers/string_erase/pop_back.pass.cpp    |  4 +++-
 .../string.modifiers/string_erase/size_size.pass.cpp   |  4 +++-
 .../string.modifiers/string_insert/iter_char.pass.cpp  |  4 +++-
 .../string_insert/iter_initializer_list.pass.cpp       |  4 +++-
 .../string_insert/iter_iter_iter.pass.cpp              |  4 +++-
 .../string_insert/iter_size_char.pass.cpp              |  4 +++-
 .../string_insert/size_T_size_size.pass.cpp            |  4 +++-
 .../string_insert/size_pointer.pass.cpp                |  4 +++-
 .../string_insert/size_pointer_size.pass.cpp           |  4 +++-
 .../string_insert/size_size_char.pass.cpp              |  4 +++-
 .../string_insert/size_string.pass.cpp                 |  4 +++-
 .../string_insert/size_string_size_size.pass.cpp       |  4 +++-
 .../string_insert/string_view.pass.cpp                 |  4 +++-
 .../string_op_plus_equal/char.pass.cpp                 |  4 +++-
 .../string_op_plus_equal/initializer_list.pass.cpp     |  4 +++-
 .../string_op_plus_equal/pointer.pass.cpp              |  4 +++-
 .../string_op_plus_equal/string.pass.cpp               |  4 +++-
 .../string_replace/iter_iter_initializer_list.pass.cpp |  4 +++-
 .../string_replace/iter_iter_iter_iter.pass.cpp        |  4 +++-
 .../string_replace/iter_iter_pointer.pass.cpp          |  4 +++-
 .../string_replace/iter_iter_pointer_size.pass.cpp     |  4 +++-
 .../string_replace/iter_iter_size_char.pass.cpp        |  4 +++-
 .../string_replace/iter_iter_string.pass.cpp           |  4 +++-
 .../string_replace/iter_iter_string_view.pass.cpp      |  4 +++-
 .../string_replace/size_size_T_size_size.pass.cpp      |  4 +++-
 .../string_replace/size_size_pointer.pass.cpp          |  4 +++-
 .../string_replace/size_size_pointer_size.pass.cpp     |  4 +++-
 .../string_replace/size_size_size_char.pass.cpp        |  4 +++-
 .../string_replace/size_size_string.pass.cpp           |  4 +++-
 .../string_replace/size_size_string_size_size.pass.cpp |  4 +++-
 .../string_replace/size_size_string_view.pass.cpp      |  4 +++-
 .../string.modifiers/string_swap/swap.pass.cpp         |  4 +++-
 .../string.nonmembers/nothing_to_do.pass.cpp           |  4 +++-
 .../string.nonmembers/string.io/get_line.pass.cpp      |  4 +++-
 .../string.io/get_line_delim.pass.cpp                  |  4 +++-
 .../string.io/get_line_delim_rv.pass.cpp               |  4 +++-
 .../string.nonmembers/string.io/get_line_rv.pass.cpp   |  4 +++-
 .../string.io/stream_extract.pass.cpp                  |  4 +++-
 .../string.nonmembers/string.io/stream_insert.pass.cpp |  4 +++-
 .../string.nonmembers/string.special/swap.pass.cpp     |  4 +++-
 .../string.special/swap_noexcept.pass.cpp              |  4 +++-
 .../string_op!=/pointer_string.pass.cpp                |  4 +++-
 .../string_op!=/string_pointer.pass.cpp                |  4 +++-
 .../string_op!=/string_string.pass.cpp                 |  4 +++-
 .../string_op!=/string_string_view.pass.cpp            |  4 +++-
 .../string_op!=/string_view_string.pass.cpp            |  4 +++-
 .../string.nonmembers/string_op+/char_string.pass.cpp  |  4 +++-
 .../string_op+/pointer_string.pass.cpp                 |  4 +++-
 .../string.nonmembers/string_op+/string_char.pass.cpp  |  4 +++-
 .../string_op+/string_pointer.pass.cpp                 |  4 +++-
 .../string_op+/string_string.pass.cpp                  |  4 +++-
 .../string_operator==/pointer_string.pass.cpp          |  4 +++-
 .../string_operator==/string_pointer.pass.cpp          |  4 +++-
 .../string_operator==/string_string.pass.cpp           |  4 +++-
 .../string_operator==/string_string_view.pass.cpp      |  4 +++-
 .../string_operator==/string_view_string.pass.cpp      |  4 +++-
 .../string_opgt/pointer_string.pass.cpp                |  4 +++-
 .../string_opgt/string_pointer.pass.cpp                |  4 +++-
 .../string_opgt/string_string.pass.cpp                 |  4 +++-
 .../string_opgt/string_string_view.pass.cpp            |  4 +++-
 .../string_opgt/string_view_string.pass.cpp            |  4 +++-
 .../string_opgt=/pointer_string.pass.cpp               |  4 +++-
 .../string_opgt=/string_pointer.pass.cpp               |  4 +++-
 .../string_opgt=/string_string.pass.cpp                |  4 +++-
 .../string_opgt=/string_string_view.pass.cpp           |  4 +++-
 .../string_opgt=/string_view_string.pass.cpp           |  4 +++-
 .../string_oplt/pointer_string.pass.cpp                |  4 +++-
 .../string_oplt/string_pointer.pass.cpp                |  4 +++-
 .../string_oplt/string_string.pass.cpp                 |  4 +++-
 .../string_oplt/string_string_view.pass.cpp            |  4 +++-
 .../string_oplt/string_view_string.pass.cpp            |  4 +++-
 .../string_oplt=/pointer_string.pass.cpp               |  4 +++-
 .../string_oplt=/string_pointer.pass.cpp               |  4 +++-
 .../string_oplt=/string_string.pass.cpp                |  4 +++-
 .../string_oplt=/string_string_view.pass.cpp           |  4 +++-
 .../string_oplt=/string_view_string.pass.cpp           |  4 +++-
 .../basic.string/string.ops/nothing_to_do.pass.cpp     |  4 +++-
 .../string.ops/string.accessors/c_str.pass.cpp         |  4 +++-
 .../string.ops/string.accessors/data.pass.cpp          |  4 +++-
 .../string.ops/string.accessors/get_allocator.pass.cpp |  4 +++-
 .../string.ops/string_compare/pointer.pass.cpp         |  4 +++-
 .../string_compare/size_size_T_size_size.pass.cpp      |  4 +++-
 .../string_compare/size_size_pointer.pass.cpp          |  4 +++-
 .../string_compare/size_size_pointer_size.pass.cpp     |  4 +++-
 .../string_compare/size_size_string.pass.cpp           |  4 +++-
 .../string_compare/size_size_string_size_size.pass.cpp |  4 +++-
 .../string_compare/size_size_string_view.pass.cpp      |  4 +++-
 .../string.ops/string_compare/string.pass.cpp          |  4 +++-
 .../string.ops/string_compare/string_view.pass.cpp     |  4 +++-
 .../string_find.first.not.of/char_size.pass.cpp        |  4 +++-
 .../string_find.first.not.of/pointer_size.pass.cpp     |  4 +++-
 .../pointer_size_size.pass.cpp                         |  4 +++-
 .../string_find.first.not.of/string_size.pass.cpp      |  4 +++-
 .../string_find.first.not.of/string_view_size.pass.cpp |  4 +++-
 .../string.ops/string_find.first.of/char_size.pass.cpp |  4 +++-
 .../string_find.first.of/pointer_size.pass.cpp         |  4 +++-
 .../string_find.first.of/pointer_size_size.pass.cpp    |  4 +++-
 .../string_find.first.of/string_size.pass.cpp          |  4 +++-
 .../string_find.first.of/string_view_size.pass.cpp     |  4 +++-
 .../string_find.last.not.of/char_size.pass.cpp         |  4 +++-
 .../string_find.last.not.of/pointer_size.pass.cpp      |  4 +++-
 .../string_find.last.not.of/pointer_size_size.pass.cpp |  4 +++-
 .../string_find.last.not.of/string_size.pass.cpp       |  4 +++-
 .../string_find.last.not.of/string_view_size.pass.cpp  |  4 +++-
 .../string.ops/string_find.last.of/char_size.pass.cpp  |  4 +++-
 .../string_find.last.of/pointer_size.pass.cpp          |  4 +++-
 .../string_find.last.of/pointer_size_size.pass.cpp     |  4 +++-
 .../string_find.last.of/string_size.pass.cpp           |  4 +++-
 .../string_find.last.of/string_view_size.pass.cpp      |  4 +++-
 .../string.ops/string_find/char_size.pass.cpp          |  4 +++-
 .../string.ops/string_find/pointer_size.pass.cpp       |  4 +++-
 .../string.ops/string_find/pointer_size_size.pass.cpp  |  4 +++-
 .../string.ops/string_find/string_size.pass.cpp        |  4 +++-
 .../string.ops/string_find/string_view_size.pass.cpp   |  4 +++-
 .../string.ops/string_rfind/char_size.pass.cpp         |  4 +++-
 .../string.ops/string_rfind/pointer_size.pass.cpp      |  4 +++-
 .../string.ops/string_rfind/pointer_size_size.pass.cpp |  4 +++-
 .../string.ops/string_rfind/string_size.pass.cpp       |  4 +++-
 .../string.ops/string_rfind/string_view_size.pass.cpp  |  4 +++-
 .../string.ops/string_substr/substr.pass.cpp           |  4 +++-
 .../basic.string/string.require/contiguous.pass.cpp    |  4 +++-
 .../string.starts_with/starts_with.char.pass.cpp       |  4 +++-
 .../string.starts_with/starts_with.ptr.pass.cpp        |  4 +++-
 .../starts_with.string_view.pass.cpp                   |  4 +++-
 test/std/strings/basic.string/traits_mismatch.fail.cpp |  4 +++-
 test/std/strings/basic.string/types.pass.cpp           |  4 +++-
 test/std/strings/c.strings/cctype.pass.cpp             |  4 +++-
 test/std/strings/c.strings/cstring.pass.cpp            |  4 +++-
 test/std/strings/c.strings/cuchar.pass.cpp             |  4 +++-
 test/std/strings/c.strings/cwchar.pass.cpp             |  4 +++-
 test/std/strings/c.strings/cwctype.pass.cpp            |  4 +++-
 .../char.traits.require/nothing_to_do.pass.cpp         |  4 +++-
 .../char.traits.specializations.char/assign2.pass.cpp  |  4 +++-
 .../char.traits.specializations.char/assign3.pass.cpp  |  4 +++-
 .../char.traits.specializations.char/compare.pass.cpp  |  4 +++-
 .../char.traits.specializations.char/copy.pass.cpp     |  4 +++-
 .../char.traits.specializations.char/eof.pass.cpp      |  4 +++-
 .../char.traits.specializations.char/eq.pass.cpp       |  4 +++-
 .../eq_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.char/find.pass.cpp     |  4 +++-
 .../char.traits.specializations.char/length.pass.cpp   |  4 +++-
 .../char.traits.specializations.char/lt.pass.cpp       |  4 +++-
 .../char.traits.specializations.char/move.pass.cpp     |  4 +++-
 .../char.traits.specializations.char/not_eof.pass.cpp  |  4 +++-
 .../to_char_type.pass.cpp                              |  4 +++-
 .../to_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.char/types.pass.cpp    |  4 +++-
 .../assign2.pass.cpp                                   |  4 +++-
 .../assign3.pass.cpp                                   |  4 +++-
 .../compare.pass.cpp                                   |  4 +++-
 .../char.traits.specializations.char16_t/copy.pass.cpp |  4 +++-
 .../char.traits.specializations.char16_t/eof.pass.cpp  |  4 +++-
 .../char.traits.specializations.char16_t/eq.pass.cpp   |  4 +++-
 .../eq_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.char16_t/find.pass.cpp |  4 +++-
 .../length.pass.cpp                                    |  4 +++-
 .../char.traits.specializations.char16_t/lt.pass.cpp   |  4 +++-
 .../char.traits.specializations.char16_t/move.pass.cpp |  4 +++-
 .../not_eof.pass.cpp                                   |  4 +++-
 .../to_char_type.pass.cpp                              |  4 +++-
 .../to_int_type.pass.cpp                               |  4 +++-
 .../types.pass.cpp                                     |  4 +++-
 .../assign2.pass.cpp                                   |  4 +++-
 .../assign3.pass.cpp                                   |  4 +++-
 .../compare.pass.cpp                                   |  4 +++-
 .../char.traits.specializations.char32_t/copy.pass.cpp |  4 +++-
 .../char.traits.specializations.char32_t/eof.pass.cpp  |  4 +++-
 .../char.traits.specializations.char32_t/eq.pass.cpp   |  4 +++-
 .../eq_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.char32_t/find.pass.cpp |  4 +++-
 .../length.pass.cpp                                    |  4 +++-
 .../char.traits.specializations.char32_t/lt.pass.cpp   |  4 +++-
 .../char.traits.specializations.char32_t/move.pass.cpp |  4 +++-
 .../not_eof.pass.cpp                                   |  4 +++-
 .../to_char_type.pass.cpp                              |  4 +++-
 .../to_int_type.pass.cpp                               |  4 +++-
 .../types.pass.cpp                                     |  4 +++-
 .../assign2.pass.cpp                                   |  6 ++++--
 .../assign3.pass.cpp                                   |  4 +++-
 .../compare.pass.cpp                                   |  6 ++++--
 .../char.traits.specializations.char8_t/copy.pass.cpp  |  4 +++-
 .../char.traits.specializations.char8_t/eof.pass.cpp   |  4 +++-
 .../char.traits.specializations.char8_t/eq.pass.cpp    |  4 +++-
 .../eq_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.char8_t/find.pass.cpp  |  6 ++++--
 .../length.pass.cpp                                    |  6 ++++--
 .../char.traits.specializations.char8_t/lt.pass.cpp    |  4 +++-
 .../char.traits.specializations.char8_t/move.pass.cpp  |  4 +++-
 .../not_eof.pass.cpp                                   |  4 +++-
 .../to_char_type.pass.cpp                              |  4 +++-
 .../to_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.char8_t/types.pass.cpp |  4 +++-
 .../assign2.pass.cpp                                   |  4 +++-
 .../assign3.pass.cpp                                   |  4 +++-
 .../compare.pass.cpp                                   |  4 +++-
 .../char.traits.specializations.wchar.t/copy.pass.cpp  |  4 +++-
 .../char.traits.specializations.wchar.t/eof.pass.cpp   |  4 +++-
 .../char.traits.specializations.wchar.t/eq.pass.cpp    |  4 +++-
 .../eq_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.wchar.t/find.pass.cpp  |  4 +++-
 .../length.pass.cpp                                    |  4 +++-
 .../char.traits.specializations.wchar.t/lt.pass.cpp    |  4 +++-
 .../char.traits.specializations.wchar.t/move.pass.cpp  |  4 +++-
 .../not_eof.pass.cpp                                   |  4 +++-
 .../to_char_type.pass.cpp                              |  4 +++-
 .../to_int_type.pass.cpp                               |  4 +++-
 .../char.traits.specializations.wchar.t/types.pass.cpp |  4 +++-
 .../char.traits.specializations/nothing_to_do.pass.cpp |  4 +++-
 .../char.traits.typedefs/nothing_to_do.pass.cpp        |  4 +++-
 test/std/strings/char.traits/nothing_to_do.pass.cpp    |  4 +++-
 test/std/strings/string.classes/typedefs.pass.cpp      |  4 +++-
 test/std/strings/string.conversions/stod.pass.cpp      |  4 +++-
 test/std/strings/string.conversions/stof.pass.cpp      |  4 +++-
 test/std/strings/string.conversions/stoi.pass.cpp      |  4 +++-
 test/std/strings/string.conversions/stol.pass.cpp      |  4 +++-
 test/std/strings/string.conversions/stold.pass.cpp     |  4 +++-
 test/std/strings/string.conversions/stoll.pass.cpp     |  4 +++-
 test/std/strings/string.conversions/stoul.pass.cpp     |  4 +++-
 test/std/strings/string.conversions/stoull.pass.cpp    |  4 +++-
 test/std/strings/string.conversions/to_string.pass.cpp |  4 +++-
 .../std/strings/string.conversions/to_wstring.pass.cpp |  4 +++-
 test/std/strings/string.view/char.bad.fail.cpp         |  4 +++-
 .../strings/string.view/string.view.access/at.pass.cpp |  4 +++-
 .../string.view/string.view.access/back.pass.cpp       |  4 +++-
 .../string.view/string.view.access/data.pass.cpp       |  4 +++-
 .../string.view/string.view.access/front.pass.cpp      |  4 +++-
 .../string.view/string.view.access/index.pass.cpp      |  4 +++-
 .../string.view/string.view.capacity/capacity.pass.cpp |  4 +++-
 .../string.view/string.view.capacity/empty.fail.cpp    |  4 +++-
 .../opeq.string_view.pointer.pass.cpp                  |  4 +++-
 .../opeq.string_view.string.pass.cpp                   |  4 +++-
 .../opeq.string_view.string_view.pass.cpp              |  4 +++-
 .../opge.string_view.pointer.pass.cpp                  |  4 +++-
 .../opge.string_view.string.pass.cpp                   |  4 +++-
 .../opge.string_view.string_view.pass.cpp              |  4 +++-
 .../opgt.string_view.pointer.pass.cpp                  |  4 +++-
 .../opgt.string_view.string.pass.cpp                   |  4 +++-
 .../opgt.string_view.string_view.pass.cpp              |  4 +++-
 .../ople.string_view.pointer.pass.cpp                  |  4 +++-
 .../ople.string_view.string.pass.cpp                   |  4 +++-
 .../ople.string_view.string_view.pass.cpp              |  4 +++-
 .../oplt.string_view.pointer.pass.cpp                  |  4 +++-
 .../oplt.string_view.string.pass.cpp                   |  4 +++-
 .../oplt.string_view.string_view.pass.cpp              |  4 +++-
 .../opne.string_view.pointer.pass.cpp                  |  4 +++-
 .../opne.string_view.string.pass.cpp                   |  4 +++-
 .../opne.string_view.string_view.pass.cpp              |  4 +++-
 .../string.view/string.view.cons/assign.pass.cpp       |  4 +++-
 .../string.view/string.view.cons/default.pass.cpp      |  4 +++-
 .../string.view/string.view.cons/from_literal.pass.cpp |  4 +++-
 .../string.view/string.view.cons/from_ptr_len.pass.cpp |  4 +++-
 .../string.view/string.view.cons/from_string.pass.cpp  |  4 +++-
 .../string.view/string.view.cons/from_string1.fail.cpp |  4 +++-
 .../string.view/string.view.cons/from_string2.fail.cpp |  4 +++-
 .../implicit_deduction_guides.pass.cpp                 |  4 +++-
 .../string.view.find/find_char_size.pass.cpp           |  4 +++-
 .../find_first_not_of_char_size.pass.cpp               |  4 +++-
 .../find_first_not_of_pointer_size.pass.cpp            |  4 +++-
 .../find_first_not_of_pointer_size_size.pass.cpp       |  4 +++-
 .../find_first_not_of_string_view_size.pass.cpp        |  4 +++-
 .../string.view.find/find_first_of_char_size.pass.cpp  |  4 +++-
 .../find_first_of_pointer_size.pass.cpp                |  4 +++-
 .../find_first_of_pointer_size_size.pass.cpp           |  4 +++-
 .../find_first_of_string_view_size.pass.cpp            |  4 +++-
 .../find_last_not_of_char_size.pass.cpp                |  4 +++-
 .../find_last_not_of_pointer_size.pass.cpp             |  4 +++-
 .../find_last_not_of_pointer_size_size.pass.cpp        |  4 +++-
 .../find_last_not_of_string_view_size.pass.cpp         |  4 +++-
 .../string.view.find/find_last_of_char_size.pass.cpp   |  4 +++-
 .../find_last_of_pointer_size.pass.cpp                 |  4 +++-
 .../find_last_of_pointer_size_size.pass.cpp            |  4 +++-
 .../find_last_of_string_view_size.pass.cpp             |  4 +++-
 .../string.view.find/find_pointer_size.pass.cpp        |  4 +++-
 .../string.view.find/find_pointer_size_size.pass.cpp   |  4 +++-
 .../string.view.find/find_string_view_size.pass.cpp    |  4 +++-
 .../string.view.find/rfind_char_size.pass.cpp          |  4 +++-
 .../string.view.find/rfind_pointer_size.pass.cpp       |  4 +++-
 .../string.view.find/rfind_pointer_size_size.pass.cpp  |  4 +++-
 .../string.view.find/rfind_string_view_size.pass.cpp   |  4 +++-
 .../string.view.hash/enabled_hashes.pass.cpp           |  4 +++-
 .../string.view/string.view.hash/string_view.pass.cpp  |  4 +++-
 .../string.view/string.view.io/stream_insert.pass.cpp  |  4 +++-
 .../string.view/string.view.iterators/begin.pass.cpp   |  4 +++-
 .../string.view/string.view.iterators/end.pass.cpp     |  4 +++-
 .../string.view/string.view.iterators/rbegin.pass.cpp  |  4 +++-
 .../string.view/string.view.iterators/rend.pass.cpp    |  4 +++-
 .../string.view.modifiers/remove_prefix.pass.cpp       |  4 +++-
 .../string.view.modifiers/remove_suffix.pass.cpp       |  4 +++-
 .../string.view/string.view.modifiers/swap.pass.cpp    |  4 +++-
 .../string.view/string.view.nonmem/quoted.pass.cpp     | 10 +++++++---
 .../string.view.ops/compare.pointer.pass.cpp           |  4 +++-
 .../string.view.ops/compare.pointer_size.pass.cpp      |  4 +++-
 .../string.view.ops/compare.size_size_sv.pass.cpp      |  4 +++-
 .../compare.size_size_sv_pointer_size.pass.cpp         |  4 +++-
 .../compare.size_size_sv_size_size.pass.cpp            |  4 +++-
 .../string.view/string.view.ops/compare.sv.pass.cpp    |  4 +++-
 .../strings/string.view/string.view.ops/copy.pass.cpp  |  4 +++-
 .../string.view/string.view.ops/substr.pass.cpp        |  4 +++-
 .../string.view.synop/nothing_to_do.pass.cpp           |  4 +++-
 .../string.view.template/ends_with.char.pass.cpp       |  4 +++-
 .../string.view.template/ends_with.ptr.pass.cpp        |  4 +++-
 .../ends_with.string_view.pass.cpp                     |  4 +++-
 .../string.view.template/nothing_to_do.pass.cpp        |  4 +++-
 .../string.view.template/starts_with.char.pass.cpp     |  4 +++-
 .../string.view.template/starts_with.ptr.pass.cpp      |  4 +++-
 .../starts_with.string_view.pass.cpp                   |  4 +++-
 .../string.view/string_view.literals/literal.pass.cpp  |  4 +++-
 .../string.view/string_view.literals/literal1.fail.cpp |  4 +++-
 .../string.view/string_view.literals/literal1.pass.cpp |  4 +++-
 .../string.view/string_view.literals/literal2.fail.cpp |  4 +++-
 .../string.view/string_view.literals/literal2.pass.cpp |  4 +++-
 .../string.view/string_view.literals/literal3.pass.cpp |  4 +++-
 test/std/strings/string.view/traits_mismatch.fail.cpp  |  4 +++-
 test/std/strings/string.view/types.pass.cpp            |  4 +++-
 test/std/strings/strings.erasure/erase.pass.cpp        |  4 +++-
 test/std/strings/strings.erasure/erase_if.pass.cpp     |  4 +++-
 .../std/strings/strings.general/nothing_to_do.pass.cpp |  4 +++-
 test/std/thread/futures/futures.async/async.fail.cpp   |  4 +++-
 test/std/thread/futures/futures.async/async.pass.cpp   |  3 ++-
 .../futures/futures.async/async_race.38682.pass.cpp    |  4 +++-
 .../thread/futures/futures.async/async_race.pass.cpp   |  4 +++-
 .../futures.errors/default_error_condition.pass.cpp    |  4 +++-
 .../futures.errors/equivalent_error_code_int.pass.cpp  |  4 +++-
 .../equivalent_int_error_condition.pass.cpp            |  4 +++-
 .../futures/futures.errors/future_category.pass.cpp    |  4 +++-
 .../futures/futures.errors/make_error_code.pass.cpp    |  4 +++-
 .../futures.errors/make_error_condition.pass.cpp       |  4 +++-
 .../thread/futures/futures.future_error/code.pass.cpp  |  4 +++-
 .../thread/futures/futures.future_error/types.pass.cpp |  4 +++-
 .../thread/futures/futures.future_error/what.pass.cpp  |  4 +++-
 .../futures/futures.overview/future_errc.pass.cpp      |  4 +++-
 .../futures/futures.overview/future_status.pass.cpp    |  4 +++-
 .../is_error_code_enum_future_errc.pass.cpp            |  4 +++-
 .../thread/futures/futures.overview/launch.pass.cpp    |  4 +++-
 .../thread/futures/futures.promise/alloc_ctor.pass.cpp |  4 +++-
 .../futures/futures.promise/copy_assign.fail.cpp       |  4 +++-
 .../thread/futures/futures.promise/copy_ctor.fail.cpp  |  4 +++-
 .../thread/futures/futures.promise/default.pass.cpp    |  4 +++-
 test/std/thread/futures/futures.promise/dtor.pass.cpp  |  4 +++-
 .../thread/futures/futures.promise/get_future.pass.cpp |  4 +++-
 .../futures/futures.promise/move_assign.pass.cpp       |  4 +++-
 .../thread/futures/futures.promise/move_ctor.pass.cpp  |  4 +++-
 .../futures/futures.promise/set_exception.pass.cpp     |  4 +++-
 .../set_exception_at_thread_exit.pass.cpp              |  4 +++-
 .../thread/futures/futures.promise/set_lvalue.pass.cpp |  4 +++-
 .../futures.promise/set_lvalue_at_thread_exit.pass.cpp |  4 +++-
 .../thread/futures/futures.promise/set_rvalue.pass.cpp |  4 +++-
 .../futures.promise/set_rvalue_at_thread_exit.pass.cpp |  4 +++-
 .../set_value_at_thread_exit_const.pass.cpp            |  4 +++-
 .../set_value_at_thread_exit_void.pass.cpp             |  4 +++-
 .../futures/futures.promise/set_value_const.pass.cpp   |  4 +++-
 .../futures/futures.promise/set_value_void.pass.cpp    |  4 +++-
 test/std/thread/futures/futures.promise/swap.pass.cpp  |  4 +++-
 .../futures/futures.promise/uses_allocator.pass.cpp    |  4 +++-
 .../futures/futures.shared_future/copy_assign.pass.cpp |  4 +++-
 .../futures/futures.shared_future/copy_ctor.pass.cpp   |  4 +++-
 .../futures/futures.shared_future/ctor_future.pass.cpp |  4 +++-
 .../futures/futures.shared_future/default.pass.cpp     |  4 +++-
 .../thread/futures/futures.shared_future/dtor.pass.cpp |  4 +++-
 .../thread/futures/futures.shared_future/get.pass.cpp  |  4 +++-
 .../futures/futures.shared_future/move_assign.pass.cpp |  4 +++-
 .../futures/futures.shared_future/move_ctor.pass.cpp   |  4 +++-
 .../thread/futures/futures.shared_future/wait.pass.cpp |  4 +++-
 .../futures/futures.shared_future/wait_for.pass.cpp    |  4 +++-
 .../futures/futures.shared_future/wait_until.pass.cpp  |  4 +++-
 .../futures/futures.state/nothing_to_do.pass.cpp       |  4 +++-
 .../futures.task.members/assign_copy.fail.cpp          |  4 +++-
 .../futures.task.members/assign_move.pass.cpp          |  4 +++-
 .../futures.task/futures.task.members/ctor1.fail.cpp   |  4 +++-
 .../futures.task/futures.task.members/ctor2.fail.cpp   |  4 +++-
 .../futures.task.members/ctor_copy.fail.cpp            |  4 +++-
 .../futures.task.members/ctor_default.pass.cpp         |  4 +++-
 .../futures.task.members/ctor_func.pass.cpp            |  4 +++-
 .../futures.task.members/ctor_func_alloc.pass.cpp      |  4 +++-
 .../futures.task.members/ctor_move.pass.cpp            |  4 +++-
 .../futures.task/futures.task.members/dtor.pass.cpp    |  4 +++-
 .../futures.task.members/get_future.pass.cpp           |  4 +++-
 .../make_ready_at_thread_exit.pass.cpp                 |  4 +++-
 .../futures.task.members/operator.pass.cpp             |  4 +++-
 .../futures.task/futures.task.members/reset.pass.cpp   |  4 +++-
 .../futures.task/futures.task.members/swap.pass.cpp    |  4 +++-
 .../futures.task/futures.task.nonmembers/swap.pass.cpp |  4 +++-
 .../futures.task.nonmembers/uses_allocator.pass.cpp    |  4 +++-
 .../futures/futures.unique_future/copy_assign.fail.cpp |  4 +++-
 .../futures/futures.unique_future/copy_ctor.fail.cpp   |  4 +++-
 .../futures/futures.unique_future/default.pass.cpp     |  4 +++-
 .../thread/futures/futures.unique_future/dtor.pass.cpp |  4 +++-
 .../thread/futures/futures.unique_future/get.pass.cpp  |  4 +++-
 .../futures/futures.unique_future/move_assign.pass.cpp |  4 +++-
 .../futures/futures.unique_future/move_ctor.pass.cpp   |  4 +++-
 .../futures/futures.unique_future/share.pass.cpp       |  4 +++-
 .../thread/futures/futures.unique_future/wait.pass.cpp |  4 +++-
 .../futures/futures.unique_future/wait_for.pass.cpp    |  4 +++-
 .../futures/futures.unique_future/wait_until.pass.cpp  |  4 +++-
 test/std/thread/macro.pass.cpp                         |  4 +++-
 test/std/thread/thread.condition/cv_status.pass.cpp    |  4 +++-
 .../notify_all_at_thread_exit.pass.cpp                 |  4 +++-
 .../thread.condition.condvar/assign.fail.cpp           |  4 +++-
 .../thread.condition.condvar/copy.fail.cpp             |  4 +++-
 .../thread.condition.condvar/default.pass.cpp          |  4 +++-
 .../thread.condition.condvar/destructor.pass.cpp       |  4 +++-
 .../thread.condition.condvar/notify_all.pass.cpp       |  4 +++-
 .../thread.condition.condvar/notify_one.pass.cpp       |  4 +++-
 .../thread.condition.condvar/wait.pass.cpp             |  4 +++-
 .../thread.condition.condvar/wait_for.pass.cpp         |  4 +++-
 .../thread.condition.condvar/wait_for_pred.pass.cpp    |  4 +++-
 .../thread.condition.condvar/wait_pred.pass.cpp        |  4 +++-
 .../thread.condition.condvar/wait_until.pass.cpp       |  4 +++-
 .../thread.condition.condvar/wait_until_pred.pass.cpp  |  4 +++-
 .../thread.condition.condvarany/assign.fail.cpp        |  4 +++-
 .../thread.condition.condvarany/copy.fail.cpp          |  4 +++-
 .../thread.condition.condvarany/default.pass.cpp       |  4 +++-
 .../thread.condition.condvarany/destructor.pass.cpp    |  4 +++-
 .../thread.condition.condvarany/notify_all.pass.cpp    |  4 +++-
 .../thread.condition.condvarany/notify_one.pass.cpp    |  4 +++-
 .../thread.condition.condvarany/wait.pass.cpp          |  4 +++-
 .../thread.condition.condvarany/wait_for.pass.cpp      |  4 +++-
 .../thread.condition.condvarany/wait_for_pred.pass.cpp |  4 +++-
 .../thread.condition.condvarany/wait_pred.pass.cpp     |  4 +++-
 .../thread.condition.condvarany/wait_terminates.sh.cpp |  4 +++-
 .../thread.condition.condvarany/wait_until.pass.cpp    |  4 +++-
 .../wait_until_pred.pass.cpp                           |  4 +++-
 test/std/thread/thread.general/nothing_to_do.pass.cpp  |  4 +++-
 .../thread.mutex/thread.lock.algorithm/lock.pass.cpp   |  4 +++-
 .../thread.lock.algorithm/try_lock.pass.cpp            |  4 +++-
 .../thread.lock/thread.lock.guard/adopt_lock.pass.cpp  |  4 +++-
 .../thread.lock/thread.lock.guard/assign.fail.cpp      |  4 +++-
 .../thread.lock/thread.lock.guard/copy.fail.cpp        |  4 +++-
 .../thread.lock/thread.lock.guard/mutex.fail.cpp       |  4 +++-
 .../thread.lock/thread.lock.guard/mutex.pass.cpp       |  4 +++-
 .../thread.lock/thread.lock.guard/types.pass.cpp       |  4 +++-
 .../thread.lock/thread.lock.scoped/adopt_lock.pass.cpp |  4 +++-
 .../thread.lock/thread.lock.scoped/assign.fail.cpp     |  4 +++-
 .../thread.lock/thread.lock.scoped/copy.fail.cpp       |  4 +++-
 .../thread.lock/thread.lock.scoped/mutex.fail.cpp      |  4 +++-
 .../thread.lock/thread.lock.scoped/mutex.pass.cpp      |  4 +++-
 .../thread.lock/thread.lock.scoped/types.pass.cpp      |  4 +++-
 .../thread.lock.shared.cons/copy_assign.fail.cpp       |  4 +++-
 .../thread.lock.shared.cons/copy_ctor.fail.cpp         |  4 +++-
 .../thread.lock.shared.cons/default.pass.cpp           |  4 +++-
 .../thread.lock.shared.cons/move_assign.pass.cpp       |  4 +++-
 .../thread.lock.shared.cons/move_ctor.pass.cpp         |  4 +++-
 .../thread.lock.shared.cons/mutex.pass.cpp             |  4 +++-
 .../thread.lock.shared.cons/mutex_adopt_lock.pass.cpp  |  4 +++-
 .../thread.lock.shared.cons/mutex_defer_lock.pass.cpp  |  4 +++-
 .../thread.lock.shared.cons/mutex_duration.pass.cpp    |  4 +++-
 .../thread.lock.shared.cons/mutex_time_point.pass.cpp  |  4 +++-
 .../thread.lock.shared.cons/mutex_try_to_lock.pass.cpp |  4 +++-
 .../thread.lock.shared.locking/lock.pass.cpp           |  4 +++-
 .../thread.lock.shared.locking/try_lock.pass.cpp       |  4 +++-
 .../thread.lock.shared.locking/try_lock_for.pass.cpp   |  4 +++-
 .../thread.lock.shared.locking/try_lock_until.pass.cpp |  4 +++-
 .../thread.lock.shared.locking/unlock.pass.cpp         |  4 +++-
 .../thread.lock.shared.mod/member_swap.pass.cpp        |  4 +++-
 .../thread.lock.shared.mod/nonmember_swap.pass.cpp     |  4 +++-
 .../thread.lock.shared.mod/release.pass.cpp            |  4 +++-
 .../thread.lock.shared.obs/mutex.pass.cpp              |  4 +++-
 .../thread.lock.shared.obs/op_bool.pass.cpp            |  4 +++-
 .../thread.lock.shared.obs/owns_lock.pass.cpp          |  4 +++-
 .../thread.lock/thread.lock.shared/types.pass.cpp      |  4 +++-
 .../thread.lock.unique.cons/copy_assign.fail.cpp       |  4 +++-
 .../thread.lock.unique.cons/copy_ctor.fail.cpp         |  4 +++-
 .../thread.lock.unique.cons/default.pass.cpp           |  4 +++-
 .../thread.lock.unique.cons/move_assign.pass.cpp       |  4 +++-
 .../thread.lock.unique.cons/move_ctor.pass.cpp         |  4 +++-
 .../thread.lock.unique.cons/mutex.pass.cpp             |  4 +++-
 .../thread.lock.unique.cons/mutex_adopt_lock.pass.cpp  |  4 +++-
 .../thread.lock.unique.cons/mutex_defer_lock.pass.cpp  |  4 +++-
 .../thread.lock.unique.cons/mutex_duration.pass.cpp    |  4 +++-
 .../thread.lock.unique.cons/mutex_time_point.pass.cpp  |  4 +++-
 .../thread.lock.unique.cons/mutex_try_to_lock.pass.cpp |  4 +++-
 .../thread.lock.unique.locking/lock.pass.cpp           |  4 +++-
 .../thread.lock.unique.locking/try_lock.pass.cpp       |  4 +++-
 .../thread.lock.unique.locking/try_lock_for.pass.cpp   |  4 +++-
 .../thread.lock.unique.locking/try_lock_until.pass.cpp |  4 +++-
 .../thread.lock.unique.locking/unlock.pass.cpp         |  4 +++-
 .../thread.lock.unique.mod/member_swap.pass.cpp        |  4 +++-
 .../thread.lock.unique.mod/nonmember_swap.pass.cpp     |  4 +++-
 .../thread.lock.unique.mod/release.pass.cpp            |  4 +++-
 .../thread.lock.unique.obs/mutex.pass.cpp              |  4 +++-
 .../thread.lock.unique.obs/op_bool.pass.cpp            |  4 +++-
 .../thread.lock.unique.obs/owns_lock.pass.cpp          |  4 +++-
 .../thread.lock/thread.lock.unique/types.pass.cpp      |  4 +++-
 .../std/thread/thread.mutex/thread.lock/types.pass.cpp |  4 +++-
 .../thread.mutex.requirements/nothing_to_do.pass.cpp   |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../thread.mutex.class/assign.fail.cpp                 |  4 +++-
 .../thread.mutex.class/copy.fail.cpp                   |  4 +++-
 .../thread.mutex.class/default.pass.cpp                |  4 +++-
 .../thread.mutex.class/lock.pass.cpp                   |  4 +++-
 .../thread.mutex.class/try_lock.pass.cpp               |  4 +++-
 .../thread.mutex.recursive/assign.fail.cpp             |  4 +++-
 .../thread.mutex.recursive/copy.fail.cpp               |  4 +++-
 .../thread.mutex.recursive/default.pass.cpp            |  4 +++-
 .../thread.mutex.recursive/lock.pass.cpp               |  4 +++-
 .../thread.mutex.recursive/try_lock.pass.cpp           |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../thread.shared_mutex.class/assign.fail.cpp          |  4 +++-
 .../thread.shared_mutex.class/copy.fail.cpp            |  4 +++-
 .../thread.shared_mutex.class/default.pass.cpp         |  4 +++-
 .../thread.shared_mutex.class/lock.pass.cpp            |  4 +++-
 .../thread.shared_mutex.class/lock_shared.pass.cpp     |  4 +++-
 .../thread.shared_mutex.class/try_lock.pass.cpp        |  4 +++-
 .../thread.shared_mutex.class/try_lock_shared.pass.cpp |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../thread.sharedtimedmutex.class/assign.fail.cpp      |  4 +++-
 .../thread.sharedtimedmutex.class/copy.fail.cpp        |  4 +++-
 .../thread.sharedtimedmutex.class/default.pass.cpp     |  4 +++-
 .../thread.sharedtimedmutex.class/lock.pass.cpp        |  4 +++-
 .../thread.sharedtimedmutex.class/lock_shared.pass.cpp |  4 +++-
 .../thread.sharedtimedmutex.class/try_lock.pass.cpp    |  4 +++-
 .../try_lock_for.pass.cpp                              |  4 +++-
 .../try_lock_shared.pass.cpp                           |  4 +++-
 .../try_lock_shared_for.pass.cpp                       |  4 +++-
 .../try_lock_shared_until.pass.cpp                     |  4 +++-
 .../try_lock_until.pass.cpp                            |  4 +++-
 .../try_lock_until_deadlock_bug.pass.cpp               |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../thread.timedmutex.class/assign.fail.cpp            |  4 +++-
 .../thread.timedmutex.class/copy.fail.cpp              |  4 +++-
 .../thread.timedmutex.class/default.pass.cpp           |  4 +++-
 .../thread.timedmutex.class/lock.pass.cpp              |  4 +++-
 .../thread.timedmutex.class/try_lock.pass.cpp          |  4 +++-
 .../thread.timedmutex.class/try_lock_for.pass.cpp      |  4 +++-
 .../thread.timedmutex.class/try_lock_until.pass.cpp    |  4 +++-
 .../thread.timedmutex.recursive/assign.fail.cpp        |  4 +++-
 .../thread.timedmutex.recursive/copy.fail.cpp          |  4 +++-
 .../thread.timedmutex.recursive/default.pass.cpp       |  4 +++-
 .../thread.timedmutex.recursive/lock.pass.cpp          |  4 +++-
 .../thread.timedmutex.recursive/try_lock.pass.cpp      |  4 +++-
 .../thread.timedmutex.recursive/try_lock_for.pass.cpp  |  4 +++-
 .../try_lock_until.pass.cpp                            |  4 +++-
 .../thread.mutex/thread.once/nothing_to_do.pass.cpp    |  4 +++-
 .../thread.once.callonce/call_once.pass.cpp            |  4 +++-
 .../thread.once/thread.once.callonce/race.pass.cpp     |  4 +++-
 .../thread.once/thread.once.onceflag/assign.fail.cpp   |  4 +++-
 .../thread.once/thread.once.onceflag/copy.fail.cpp     |  4 +++-
 .../thread.once/thread.once.onceflag/default.pass.cpp  |  4 +++-
 test/std/thread/thread.req/nothing_to_do.pass.cpp      |  4 +++-
 .../thread.req.exception/nothing_to_do.pass.cpp        |  4 +++-
 .../thread.req.lockable/nothing_to_do.pass.cpp         |  4 +++-
 .../thread.req.lockable.basic/nothing_to_do.pass.cpp   |  4 +++-
 .../thread.req.lockable.general/nothing_to_do.pass.cpp |  4 +++-
 .../thread.req.lockable.req/nothing_to_do.pass.cpp     |  4 +++-
 .../thread.req.lockable.timed/nothing_to_do.pass.cpp   |  4 +++-
 .../thread.req.native/nothing_to_do.pass.cpp           |  4 +++-
 .../thread.req.paramname/nothing_to_do.pass.cpp        |  4 +++-
 .../thread.req.timing/nothing_to_do.pass.cpp           |  4 +++-
 .../thread.thread.algorithm/swap.pass.cpp              |  4 +++-
 .../thread.thread.assign/copy.fail.cpp                 |  4 +++-
 .../thread.thread.assign/move.pass.cpp                 |  4 +++-
 .../thread.thread.assign/move2.pass.cpp                |  4 +++-
 .../thread.thread.constr/F.pass.cpp                    |  4 +++-
 .../thread.thread.constr/constr.fail.cpp               |  4 +++-
 .../thread.thread.constr/copy.fail.cpp                 |  4 +++-
 .../thread.thread.constr/default.pass.cpp              |  4 +++-
 .../thread.thread.constr/move.pass.cpp                 |  4 +++-
 .../thread.thread.destr/dtor.pass.cpp                  |  4 +++-
 .../thread.thread.id/assign.pass.cpp                   |  4 +++-
 .../thread.thread.class/thread.thread.id/copy.pass.cpp |  4 +++-
 .../thread.thread.id/default.pass.cpp                  |  4 +++-
 .../thread.thread.id/enabled_hashes.pass.cpp           |  4 +++-
 .../thread.thread.class/thread.thread.id/eq.pass.cpp   |  4 +++-
 .../thread.thread.class/thread.thread.id/lt.pass.cpp   |  4 +++-
 .../thread.thread.id/stream.pass.cpp                   |  4 +++-
 .../thread.thread.id/thread_id.pass.cpp                |  4 +++-
 .../thread.thread.member/detach.pass.cpp               |  4 +++-
 .../thread.thread.member/get_id.pass.cpp               |  4 +++-
 .../thread.thread.member/join.pass.cpp                 |  4 +++-
 .../thread.thread.member/joinable.pass.cpp             |  4 +++-
 .../thread.thread.member/swap.pass.cpp                 |  4 +++-
 .../thread.thread.static/hardware_concurrency.pass.cpp |  4 +++-
 .../thread.threads/thread.thread.this/get_id.pass.cpp  |  4 +++-
 .../sleep_for_tested_elsewhere.pass.cpp                |  4 +++-
 .../thread.thread.this/sleep_until.pass.cpp            |  4 +++-
 .../thread.threads/thread.thread.this/yield.pass.cpp   |  4 +++-
 .../allocator.adaptor.cnstr/allocs.pass.cpp            |  4 +++-
 .../allocator.adaptor.cnstr/converting_copy.pass.cpp   |  4 +++-
 .../allocator.adaptor.cnstr/converting_move.pass.cpp   |  4 +++-
 .../allocator.adaptor.cnstr/copy.pass.cpp              |  4 +++-
 .../allocator.adaptor.cnstr/default.pass.cpp           |  4 +++-
 .../allocator.adaptor.members/allocate_size.fail.cpp   |  4 +++-
 .../allocator.adaptor.members/allocate_size.pass.cpp   |  4 +++-
 .../allocate_size_hint.fail.cpp                        |  4 +++-
 .../allocate_size_hint.pass.cpp                        |  4 +++-
 .../allocator.adaptor.members/construct.pass.cpp       |  4 +++-
 .../allocator.adaptor.members/construct_pair.pass.cpp  |  4 +++-
 .../construct_pair_const_lvalue_pair.pass.cpp          |  4 +++-
 .../construct_pair_piecewise.pass.cpp                  |  4 +++-
 .../construct_pair_rvalue.pass.cpp                     |  4 +++-
 .../construct_pair_values.pass.cpp                     |  4 +++-
 .../allocator.adaptor.members/construct_type.pass.cpp  |  4 +++-
 .../allocator.adaptor.members/deallocate.pass.cpp      |  4 +++-
 .../allocator.adaptor.members/destroy.pass.cpp         |  4 +++-
 .../allocator.adaptor.members/inner_allocator.pass.cpp |  4 +++-
 .../allocator.adaptor.members/max_size.pass.cpp        |  4 +++-
 .../allocator.adaptor.members/outer_allocator.pass.cpp |  4 +++-
 .../select_on_container_copy_construction.pass.cpp     |  4 +++-
 .../allocator_pointers.pass.cpp                        |  6 ++++--
 .../inner_allocator_type.pass.cpp                      |  4 +++-
 .../allocator.adaptor.types/is_always_equal.pass.cpp   |  4 +++-
 .../propagate_on_container_copy_assignment.pass.cpp    |  4 +++-
 .../propagate_on_container_move_assignment.pass.cpp    |  4 +++-
 .../propagate_on_container_swap.pass.cpp               |  4 +++-
 .../scoped.adaptor.operators/copy_assign.pass.cpp      |  4 +++-
 .../scoped.adaptor.operators/eq.pass.cpp               |  4 +++-
 .../scoped.adaptor.operators/move_assign.pass.cpp      |  4 +++-
 test/std/utilities/allocator.adaptor/types.pass.cpp    |  4 +++-
 .../utilities/any/any.class/any.assign/copy.pass.cpp   |  4 +++-
 .../utilities/any/any.class/any.assign/move.pass.cpp   |  4 +++-
 .../utilities/any/any.class/any.assign/value.pass.cpp  |  4 +++-
 .../std/utilities/any/any.class/any.cons/copy.pass.cpp |  4 +++-
 .../utilities/any/any.class/any.cons/default.pass.cpp  |  4 +++-
 .../any/any.class/any.cons/in_place_type.pass.cpp      |  4 +++-
 .../std/utilities/any/any.class/any.cons/move.pass.cpp |  4 +++-
 .../utilities/any/any.class/any.cons/value.pass.cpp    |  4 +++-
 .../any/any.class/any.modifiers/emplace.pass.cpp       |  4 +++-
 .../any/any.class/any.modifiers/reset.pass.cpp         |  4 +++-
 .../any/any.class/any.modifiers/swap.pass.cpp          |  4 +++-
 .../any/any.class/any.observers/has_value.pass.cpp     |  4 +++-
 .../any/any.class/any.observers/type.pass.cpp          |  4 +++-
 .../utilities/any/any.class/not_literal_type.pass.cpp  |  4 +++-
 .../any.nonmembers/any.cast/any_cast_pointer.pass.cpp  |  4 +++-
 .../any.cast/any_cast_reference.pass.cpp               |  4 +++-
 .../any_cast_request_invalid_value_category.fail.cpp   |  4 +++-
 .../any.nonmembers/any.cast/const_correctness.fail.cpp |  4 +++-
 .../any.cast/not_copy_constructible.fail.cpp           |  4 +++-
 .../any.nonmembers/any.cast/reference_types.fail.cpp   |  4 +++-
 .../std/utilities/any/any.nonmembers/make_any.pass.cpp |  4 +++-
 test/std/utilities/any/any.nonmembers/swap.pass.cpp    |  4 +++-
 .../charconv.from.chars/integral.bool.fail.cpp         |  4 +++-
 .../charconv/charconv.from.chars/integral.pass.cpp     |  4 +++-
 .../charconv/charconv.to.chars/integral.bool.fail.cpp  |  4 +++-
 .../charconv/charconv.to.chars/integral.pass.cpp       |  4 +++-
 .../arithmetic.operations/divides.pass.cpp             |  4 +++-
 .../arithmetic.operations/minus.pass.cpp               |  4 +++-
 .../arithmetic.operations/modulus.pass.cpp             |  4 +++-
 .../arithmetic.operations/multiplies.pass.cpp          |  4 +++-
 .../arithmetic.operations/negate.pass.cpp              |  4 +++-
 .../arithmetic.operations/plus.pass.cpp                |  4 +++-
 .../arithmetic.operations/transparent.pass.cpp         |  2 +-
 .../PR23141_invoke_not_constexpr.pass.cpp              |  4 +++-
 .../func.bind/func.bind.bind/bind_return_type.pass.cpp |  4 +++-
 .../bind/func.bind/func.bind.bind/copy.pass.cpp        |  4 +++-
 .../func.bind.bind/invoke_function_object.pass.cpp     |  4 +++-
 .../func.bind/func.bind.bind/invoke_int_0.pass.cpp     |  4 +++-
 .../func.bind/func.bind.bind/invoke_lvalue.pass.cpp    |  4 +++-
 .../func.bind/func.bind.bind/invoke_rvalue.pass.cpp    |  4 +++-
 .../func.bind/func.bind.bind/invoke_void_0.pass.cpp    |  4 +++-
 .../bind/func.bind/func.bind.bind/nested.pass.cpp      |  4 +++-
 .../func.bind.isbind/is_bind_expression.pass.cpp       |  4 +++-
 .../func.bind.isbind/is_bind_expression_03.pass.cpp    |  4 +++-
 .../func.bind/func.bind.isbind/is_placeholder.pass.cpp |  4 +++-
 .../func.bind/func.bind.place/placeholders.pass.cpp    |  4 +++-
 .../bind/func.bind/nothing_to_do.pass.cpp              |  4 +++-
 .../function.objects/bind/nothing_to_do.pass.cpp       |  4 +++-
 .../bitwise.operations/bit_and.pass.cpp                |  4 +++-
 .../bitwise.operations/bit_not.pass.cpp                |  4 +++-
 .../bitwise.operations/bit_or.pass.cpp                 |  4 +++-
 .../bitwise.operations/bit_xor.pass.cpp                |  4 +++-
 .../bitwise.operations/transparent.pass.cpp            |  2 +-
 .../comparisons/constexpr_init.pass.cpp                |  4 +++-
 .../function.objects/comparisons/equal_to.pass.cpp     |  4 +++-
 .../function.objects/comparisons/greater.pass.cpp      |  4 +++-
 .../comparisons/greater_equal.pass.cpp                 |  4 +++-
 .../function.objects/comparisons/less.pass.cpp         |  4 +++-
 .../function.objects/comparisons/less_equal.pass.cpp   |  4 +++-
 .../function.objects/comparisons/not_equal_to.pass.cpp |  4 +++-
 .../function.objects/comparisons/transparent.pass.cpp  |  2 +-
 .../function.objects/func.def/nothing_to_do.pass.cpp   |  4 +++-
 .../function.objects/func.invoke/invoke.pass.cpp       |  4 +++-
 .../func.invoke/invoke_feature_test_macro.pass.cpp     |  4 +++-
 .../function.objects/func.memfn/member_data.fail.cpp   |  4 +++-
 .../function.objects/func.memfn/member_data.pass.cpp   |  4 +++-
 .../func.memfn/member_function.pass.cpp                |  4 +++-
 .../func.memfn/member_function_const.pass.cpp          |  4 +++-
 .../func.memfn/member_function_const_volatile.pass.cpp |  4 +++-
 .../func.memfn/member_function_volatile.pass.cpp       |  4 +++-
 .../function.objects/func.not_fn/not_fn.pass.cpp       |  4 +++-
 .../func.require/INVOKE_tested_elsewhere.pass.cpp      |  4 +++-
 .../func.require/binary_function.pass.cpp              |  4 +++-
 .../func.require/unary_function.pass.cpp               |  4 +++-
 .../func.search/func.search.bm/default.pass.cpp        |  4 +++-
 .../func.search/func.search.bm/hash.pass.cpp           |  4 +++-
 .../func.search/func.search.bm/hash.pred.pass.cpp      |  4 +++-
 .../func.search/func.search.bm/pred.pass.cpp           |  4 +++-
 .../func.search/func.search.bmh/default.pass.cpp       |  4 +++-
 .../func.search/func.search.bmh/hash.pass.cpp          |  4 +++-
 .../func.search/func.search.bmh/hash.pred.pass.cpp     |  4 +++-
 .../func.search/func.search.bmh/pred.pass.cpp          |  4 +++-
 .../func.search/func.search.default/default.pass.cpp   |  4 +++-
 .../func.search.default/default.pred.pass.cpp          |  4 +++-
 .../func.search/nothing_to_do.pass.cpp                 |  4 +++-
 .../func.wrap.badcall/bad_function_call.pass.cpp       |  4 +++-
 .../bad_function_call_ctor.pass.cpp                    |  4 +++-
 .../func.wrap/func.wrap.func/derive_from.fail.cpp      |  4 +++-
 .../func.wrap/func.wrap.func/derive_from.pass.cpp      |  4 +++-
 .../func.wrap.func/func.wrap.func.alg/swap.pass.cpp    |  4 +++-
 .../func.wrap.func.cap/operator_bool.pass.cpp          |  4 +++-
 .../func.wrap.func/func.wrap.func.con/F.pass.cpp       |  4 +++-
 .../func.wrap.func.con/F_assign.pass.cpp               |  4 +++-
 .../func.wrap.func.con/F_incomplete.pass.cpp           |  4 +++-
 .../func.wrap.func.con/F_nullptr.pass.cpp              |  4 +++-
 .../func.wrap.func/func.wrap.func.con/alloc.fail.cpp   |  4 +++-
 .../func.wrap.func/func.wrap.func.con/alloc.pass.cpp   |  4 +++-
 .../func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp |  4 +++-
 .../func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp |  4 +++-
 .../func.wrap.func.con/alloc_function.fail.cpp         |  4 +++-
 .../func.wrap.func.con/alloc_function.pass.cpp         |  4 +++-
 .../func.wrap.func.con/alloc_nullptr.fail.cpp          |  4 +++-
 .../func.wrap.func.con/alloc_nullptr.pass.cpp          |  4 +++-
 .../func.wrap.func.con/alloc_rfunction.fail.cpp        |  4 +++-
 .../func.wrap.func.con/alloc_rfunction.pass.cpp        |  4 +++-
 .../func.wrap.func.con/copy_assign.pass.cpp            |  4 +++-
 .../func.wrap.func.con/copy_move.pass.cpp              |  4 +++-
 .../func.wrap.func/func.wrap.func.con/default.pass.cpp |  4 +++-
 .../func.wrap.func.con/move_reentrant.pass.cpp         |  4 +++-
 .../func.wrap.func.con/nullptr_t.pass.cpp              |  4 +++-
 .../func.wrap.func.con/nullptr_t_assign.pass.cpp       |  4 +++-
 .../nullptr_t_assign_reentrant.pass.cpp                |  4 +++-
 .../func.wrap.func/func.wrap.func.inv/invoke.fail.cpp  |  4 +++-
 .../func.wrap.func/func.wrap.func.inv/invoke.pass.cpp  |  4 +++-
 .../func.wrap.func.mod/assign_F_alloc.pass.cpp         |  4 +++-
 .../func.wrap.func/func.wrap.func.mod/swap.pass.cpp    |  4 +++-
 .../func.wrap.func.nullptr/operator_==.pass.cpp        |  4 +++-
 .../func.wrap.func/func.wrap.func.targ/target.pass.cpp |  4 +++-
 .../func.wrap.func.targ/target_type.pass.cpp           |  4 +++-
 .../func.wrap/func.wrap.func/types.pass.cpp            |  4 +++-
 .../function.objects/func.wrap/nothing_to_do.pass.cpp  |  4 +++-
 .../logical.operations/logical_and.pass.cpp            |  4 +++-
 .../logical.operations/logical_not.pass.cpp            |  4 +++-
 .../logical.operations/logical_or.pass.cpp             |  4 +++-
 .../logical.operations/transparent.pass.cpp            |  2 +-
 .../negators/binary_negate.depr_in_cxx17.fail.cpp      |  4 +++-
 .../function.objects/negators/binary_negate.pass.cpp   |  4 +++-
 .../negators/not1.depr_in_cxx17.fail.cpp               |  4 +++-
 .../utilities/function.objects/negators/not1.pass.cpp  |  4 +++-
 .../negators/not2.depr_in_cxx17.fail.cpp               |  4 +++-
 .../utilities/function.objects/negators/not2.pass.cpp  |  4 +++-
 .../negators/unary_negate.depr_in_cxx17.fail.cpp       |  4 +++-
 .../function.objects/negators/unary_negate.pass.cpp    |  4 +++-
 .../refwrap/refwrap.access/conversion.pass.cpp         |  4 +++-
 .../refwrap/refwrap.assign/copy_assign.pass.cpp        |  4 +++-
 .../refwrap/refwrap.const/copy_ctor.pass.cpp           |  4 +++-
 .../refwrap/refwrap.const/type_ctor.fail.cpp           |  4 +++-
 .../refwrap/refwrap.const/type_ctor.pass.cpp           |  4 +++-
 .../refwrap/refwrap.helpers/cref_1.pass.cpp            |  4 +++-
 .../refwrap/refwrap.helpers/cref_2.pass.cpp            |  4 +++-
 .../refwrap/refwrap.helpers/ref_1.fail.cpp             |  4 +++-
 .../refwrap/refwrap.helpers/ref_1.pass.cpp             |  4 +++-
 .../refwrap/refwrap.helpers/ref_2.pass.cpp             |  4 +++-
 .../refwrap/refwrap.invoke/invoke.fail.cpp             |  4 +++-
 .../refwrap/refwrap.invoke/invoke.pass.cpp             |  4 +++-
 .../refwrap/refwrap.invoke/invoke_int_0.pass.cpp       |  4 +++-
 .../refwrap/refwrap.invoke/invoke_void_0.pass.cpp      |  4 +++-
 .../utilities/function.objects/refwrap/type.pass.cpp   |  4 +++-
 .../function.objects/refwrap/type_properties.pass.cpp  |  4 +++-
 .../function.objects/refwrap/unwrap_ref_decay.pass.cpp |  4 +++-
 .../function.objects/refwrap/unwrap_reference.pass.cpp |  4 +++-
 .../function.objects/refwrap/weak_result.pass.cpp      |  4 +++-
 .../unord.hash/enabled_hashes.pass.cpp                 |  4 +++-
 .../function.objects/unord.hash/enum.fail.cpp          |  4 +++-
 .../function.objects/unord.hash/enum.pass.cpp          |  4 +++-
 .../function.objects/unord.hash/floating.pass.cpp      |  4 +++-
 .../function.objects/unord.hash/integral.pass.cpp      |  4 +++-
 .../function.objects/unord.hash/non_enum.pass.cpp      |  4 +++-
 .../function.objects/unord.hash/pointer.pass.cpp       |  4 +++-
 .../intseq/intseq.general/integer_seq.pass.cpp         |  4 +++-
 .../intseq/intseq.intseq/integer_seq.fail.cpp          |  4 +++-
 .../intseq/intseq.intseq/integer_seq.pass.cpp          |  4 +++-
 .../intseq/intseq.make/make_integer_seq.fail.cpp       |  4 +++-
 .../intseq/intseq.make/make_integer_seq.pass.cpp       |  4 +++-
 test/std/utilities/intseq/nothing_to_do.pass.cpp       |  4 +++-
 .../memory/allocator.tag/allocator_arg.pass.cpp        |  4 +++-
 .../allocator.traits.members/allocate.fail.cpp         |  4 +++-
 .../allocator.traits.members/allocate.pass.cpp         |  4 +++-
 .../allocator.traits.members/allocate_hint.pass.cpp    |  4 +++-
 .../allocator.traits.members/construct.pass.cpp        |  4 +++-
 .../allocator.traits.members/deallocate.pass.cpp       |  4 +++-
 .../allocator.traits.members/destroy.pass.cpp          |  4 +++-
 .../allocator.traits.members/max_size.pass.cpp         |  4 +++-
 .../select_on_container_copy_construction.pass.cpp     |  4 +++-
 .../allocator.traits.types/const_pointer.pass.cpp      |  4 +++-
 .../allocator.traits.types/const_void_pointer.pass.cpp |  4 +++-
 .../allocator.traits.types/difference_type.pass.cpp    |  4 +++-
 .../allocator.traits.types/is_always_equal.pass.cpp    |  4 +++-
 .../allocator.traits.types/pointer.pass.cpp            |  4 +++-
 .../propagate_on_container_copy_assignment.pass.cpp    |  4 +++-
 .../propagate_on_container_move_assignment.pass.cpp    |  4 +++-
 .../propagate_on_container_swap.pass.cpp               |  4 +++-
 .../allocator.traits.types/rebind_alloc.pass.cpp       |  4 +++-
 .../allocator.traits.types/size_type.pass.cpp          |  4 +++-
 .../allocator.traits.types/void_pointer.pass.cpp       |  4 +++-
 .../memory/allocator.traits/allocator_type.pass.cpp    |  4 +++-
 .../memory/allocator.traits/rebind_traits.pass.cpp     |  4 +++-
 .../memory/allocator.traits/value_type.pass.cpp        |  4 +++-
 .../tested_elsewhere.pass.cpp                          |  4 +++-
 .../allocator.uses.trait/uses_allocator.pass.cpp       |  4 +++-
 .../memory/allocator.uses/nothing_to_do.pass.cpp       |  4 +++-
 .../utilities/memory/c.malloc/nothing_to_do.pass.cpp   |  4 +++-
 .../memory/default.allocator/allocator.ctor.pass.cpp   |  4 +++-
 .../default.allocator/allocator.globals/eq.pass.cpp    |  4 +++-
 .../allocator.members/address.pass.cpp                 |  4 +++-
 .../allocator.members/allocate.fail.cpp                |  4 +++-
 .../allocator.members/allocate.pass.cpp                |  4 +++-
 .../allocator.members/allocate.size.pass.cpp           |  4 +++-
 .../allocator.members/construct.pass.cpp               |  4 +++-
 .../allocator.members/max_size.pass.cpp                |  4 +++-
 .../default.allocator/allocator_pointers.pass.cpp      |  6 ++++--
 .../memory/default.allocator/allocator_types.pass.cpp  |  4 +++-
 .../memory/default.allocator/allocator_void.pass.cpp   |  4 +++-
 .../memory/pointer.conversion/to_address.pass.cpp      |  4 +++-
 .../memory/pointer.traits/difference_type.pass.cpp     |  4 +++-
 .../memory/pointer.traits/element_type.pass.cpp        |  4 +++-
 .../utilities/memory/pointer.traits/pointer.pass.cpp   |  4 +++-
 .../pointer.traits.functions/pointer_to.pass.cpp       |  4 +++-
 .../pointer.traits.types/difference_type.pass.cpp      |  4 +++-
 .../pointer.traits.types/element_type.pass.cpp         |  4 +++-
 .../pointer.traits.types/rebind.pass.cpp               |  4 +++-
 .../memory/pointer.traits/pointer_to.pass.cpp          |  4 +++-
 .../utilities/memory/pointer.traits/rebind.pass.cpp    |  4 +++-
 test/std/utilities/memory/ptr.align/align.pass.cpp     |  4 +++-
 .../specialized.algorithms/nothing_to_do.pass.cpp      |  4 +++-
 .../specialized.addressof/addressof.pass.cpp           |  4 +++-
 .../specialized.addressof/addressof.temp.fail.cpp      |  4 +++-
 .../specialized.addressof/constexpr_addressof.pass.cpp |  4 +++-
 .../specialized.destroy/destroy.pass.cpp               |  4 +++-
 .../specialized.destroy/destroy_at.pass.cpp            |  4 +++-
 .../specialized.destroy/destroy_n.pass.cpp             |  4 +++-
 .../uninitialized_default_construct.pass.cpp           |  4 +++-
 .../uninitialized_default_construct_n.pass.cpp         |  4 +++-
 .../uninitialized_value_construct.pass.cpp             |  4 +++-
 .../uninitialized_value_construct_n.pass.cpp           |  4 +++-
 .../uninitialized.copy/uninitialized_copy.pass.cpp     |  4 +++-
 .../uninitialized.copy/uninitialized_copy_n.pass.cpp   |  4 +++-
 .../uninitialized.fill.n/uninitialized_fill_n.pass.cpp |  4 +++-
 .../uninitialized.fill/uninitialized_fill.pass.cpp     |  4 +++-
 .../uninitialized.move/uninitialized_move.pass.cpp     |  4 +++-
 .../uninitialized.move/uninitialized_move_n.pass.cpp   |  4 +++-
 .../raw_storage_iterator.base.pass.cpp                 |  4 +++-
 .../storage.iterator/raw_storage_iterator.pass.cpp     |  4 +++-
 .../memory/temporary.buffer/overaligned.pass.cpp       |  4 +++-
 .../memory/temporary.buffer/temporary_buffer.pass.cpp  |  4 +++-
 .../memory/unique.ptr/unique.ptr.special/io.fail.cpp   |  4 +++-
 .../memory/unique.ptr/unique.ptr.special/io.pass.cpp   |  4 +++-
 .../util.dynamic.safety/declare_no_pointers.pass.cpp   |  4 +++-
 .../util.dynamic.safety/declare_reachable.pass.cpp     |  4 +++-
 .../util.dynamic.safety/get_pointer_safety.pass.cpp    |  4 +++-
 .../memory/util.smartptr/nothing_to_do.pass.cpp        |  4 +++-
 .../enable_shared_from_this.pass.cpp                   |  4 +++-
 .../util.smartptr.hash/enabled_hash.pass.cpp           |  4 +++-
 .../util.smartptr.hash/hash_shared_ptr.pass.cpp        |  4 +++-
 .../util.smartptr.hash/hash_unique_ptr.pass.cpp        |  4 +++-
 .../atomic_compare_exchange_strong.pass.cpp            |  4 +++-
 .../atomic_compare_exchange_strong_explicit.pass.cpp   |  4 +++-
 .../atomic_compare_exchange_weak.pass.cpp              |  4 +++-
 .../atomic_compare_exchange_weak_explicit.pass.cpp     |  4 +++-
 .../atomic_exchange.pass.cpp                           |  4 +++-
 .../atomic_exchange_explicit.pass.cpp                  |  4 +++-
 .../atomic_is_lock_free.pass.cpp                       |  4 +++-
 .../util.smartptr.shared.atomic/atomic_load.pass.cpp   |  4 +++-
 .../atomic_load_explicit.pass.cpp                      |  4 +++-
 .../util.smartptr.shared.atomic/atomic_store.pass.cpp  |  4 +++-
 .../atomic_store_explicit.pass.cpp                     |  4 +++-
 .../util.smartptr/util.smartptr.shared/types.pass.cpp  |  4 +++-
 .../util.smartptr.getdeleter/get_deleter.pass.cpp      |  4 +++-
 .../util.smartptr.shared.assign/auto_ptr_Y.pass.cpp    |  4 +++-
 .../util.smartptr.shared.assign/shared_ptr.pass.cpp    |  4 +++-
 .../util.smartptr.shared.assign/shared_ptr_Y.pass.cpp  |  4 +++-
 .../shared_ptr_Y_rv.pass.cpp                           |  4 +++-
 .../util.smartptr.shared.assign/shared_ptr_rv.pass.cpp |  4 +++-
 .../util.smartptr.shared.assign/unique_ptr_Y.pass.cpp  |  4 +++-
 .../const_pointer_cast.pass.cpp                        |  4 +++-
 .../dynamic_pointer_cast.pass.cpp                      |  4 +++-
 .../static_pointer_cast.pass.cpp                       |  4 +++-
 .../util.smartptr.shared.cmp/cmp_nullptr.pass.cpp      |  4 +++-
 .../util.smartptr.shared.cmp/eq.pass.cpp               |  4 +++-
 .../util.smartptr.shared.cmp/lt.pass.cpp               |  4 +++-
 .../util.smartptr.shared.const/auto_ptr.pass.cpp       |  4 +++-
 .../util.smartptr.shared.const/default.pass.cpp        |  4 +++-
 .../util.smartptr.shared.const/nullptr_t.pass.cpp      |  4 +++-
 .../nullptr_t_deleter.pass.cpp                         |  4 +++-
 .../nullptr_t_deleter_allocator.pass.cpp               |  4 +++-
 .../nullptr_t_deleter_allocator_throw.pass.cpp         |  4 +++-
 .../nullptr_t_deleter_throw.pass.cpp                   |  4 +++-
 .../util.smartptr.shared.const/pointer.pass.cpp        |  4 +++-
 .../pointer_deleter.pass.cpp                           |  4 +++-
 .../pointer_deleter_allocator.pass.cpp                 |  4 +++-
 .../pointer_deleter_allocator_throw.pass.cpp           |  4 +++-
 .../pointer_deleter_throw.pass.cpp                     |  4 +++-
 .../util.smartptr.shared.const/pointer_throw.pass.cpp  |  4 +++-
 .../util.smartptr.shared.const/shared_ptr.pass.cpp     |  4 +++-
 .../util.smartptr.shared.const/shared_ptr_Y.pass.cpp   |  4 +++-
 .../shared_ptr_Y_rv.pass.cpp                           |  4 +++-
 .../shared_ptr_pointer.pass.cpp                        |  4 +++-
 .../util.smartptr.shared.const/shared_ptr_rv.pass.cpp  |  4 +++-
 .../util.smartptr.shared.const/unique_ptr.pass.cpp     |  4 +++-
 .../util.smartptr.shared.const/weak_ptr.pass.cpp       |  4 +++-
 .../allocate_shared.pass.cpp                           |  4 +++-
 .../allocate_shared_cxx03.pass.cpp                     |  4 +++-
 .../util.smartptr.shared.create/make_shared.pass.cpp   |  4 +++-
 .../make_shared.private.fail.cpp                       |  4 +++-
 .../make_shared.protected.fail.cpp                     |  4 +++-
 .../make_shared.volatile.pass.cpp                      |  4 +++-
 .../tested_elsewhere.pass.cpp                          |  4 +++-
 .../util.smartptr.shared.io/io.pass.cpp                |  4 +++-
 .../util.smartptr.shared.mod/reset.pass.cpp            |  4 +++-
 .../util.smartptr.shared.mod/reset_pointer.pass.cpp    |  4 +++-
 .../reset_pointer_deleter.pass.cpp                     |  4 +++-
 .../reset_pointer_deleter_allocator.pass.cpp           |  4 +++-
 .../util.smartptr.shared.mod/swap.pass.cpp             |  4 +++-
 .../util.smartptr.shared.obs/arrow.pass.cpp            |  4 +++-
 .../util.smartptr.shared.obs/dereference.pass.cpp      |  4 +++-
 .../util.smartptr.shared.obs/op_bool.pass.cpp          |  4 +++-
 .../owner_before_shared_ptr.pass.cpp                   |  4 +++-
 .../owner_before_weak_ptr.pass.cpp                     |  4 +++-
 .../util.smartptr.shared.obs/unique.pass.cpp           |  4 +++-
 .../util.smartptr.shared.spec/swap.pass.cpp            |  4 +++-
 .../util.smartptr/util.smartptr.weak/types.pass.cpp    |  4 +++-
 .../util.smartptr.ownerless/owner_less.pass.cpp        |  4 +++-
 .../util.smartptr.weak.assign/shared_ptr_Y.pass.cpp    |  4 +++-
 .../util.smartptr.weak.assign/weak_ptr.pass.cpp        |  4 +++-
 .../util.smartptr.weak.assign/weak_ptr_Y.pass.cpp      |  4 +++-
 .../util.smartptr.weak.const/default.pass.cpp          |  4 +++-
 .../util.smartptr.weak.const/shared_ptr_Y.pass.cpp     |  4 +++-
 .../util.smartptr.weak.const/weak_ptr.pass.cpp         |  4 +++-
 .../util.smartptr.weak.const/weak_ptr_Y.pass.cpp       |  4 +++-
 .../util.smartptr.weak.dest/tested_elsewhere.pass.cpp  |  4 +++-
 .../util.smartptr.weak.mod/reset.pass.cpp              |  4 +++-
 .../util.smartptr.weak.mod/swap.pass.cpp               |  4 +++-
 .../util.smartptr.weak.obs/expired.pass.cpp            |  4 +++-
 .../util.smartptr.weak.obs/lock.pass.cpp               |  4 +++-
 .../util.smartptr.weak.obs/not_less_than.fail.cpp      |  4 +++-
 .../owner_before_shared_ptr.pass.cpp                   |  4 +++-
 .../owner_before_weak_ptr.pass.cpp                     |  4 +++-
 .../util.smartptr.weak.spec/swap.pass.cpp              |  4 +++-
 .../util.smartptr.weakptr/bad_weak_ptr.pass.cpp        |  4 +++-
 .../utilities/meta/meta.help/bool_constant.pass.cpp    |  4 +++-
 .../meta/meta.help/integral_constant.pass.cpp          |  4 +++-
 .../utilities/meta/meta.logical/conjunction.pass.cpp   |  4 +++-
 .../utilities/meta/meta.logical/disjunction.pass.cpp   |  4 +++-
 test/std/utilities/meta/meta.logical/negation.pass.cpp |  4 +++-
 test/std/utilities/meta/meta.rel/is_base_of.pass.cpp   |  4 +++-
 .../utilities/meta/meta.rel/is_convertible.pass.cpp    |  4 +++-
 test/std/utilities/meta/meta.rel/is_invocable.pass.cpp |  3 ++-
 .../meta/meta.rel/is_nothrow_invocable.pass.cpp        |  4 +++-
 test/std/utilities/meta/meta.rel/is_same.pass.cpp      |  4 +++-
 .../utilities/meta/meta.rqmts/nothing_to_do.pass.cpp   |  4 +++-
 .../meta.trans.arr/remove_all_extents.pass.cpp         |  4 +++-
 .../meta.trans/meta.trans.arr/remove_extent.pass.cpp   |  4 +++-
 .../meta/meta.trans/meta.trans.cv/add_const.pass.cpp   |  4 +++-
 .../meta/meta.trans/meta.trans.cv/add_cv.pass.cpp      |  4 +++-
 .../meta.trans/meta.trans.cv/add_volatile.pass.cpp     |  4 +++-
 .../meta.trans/meta.trans.cv/remove_const.pass.cpp     |  4 +++-
 .../meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp   |  4 +++-
 .../meta.trans/meta.trans.cv/remove_volatile.pass.cpp  |  4 +++-
 .../meta.trans.other/aligned_storage.pass.cpp          |  4 +++-
 .../meta.trans/meta.trans.other/aligned_union.fail.cpp |  4 +++-
 .../meta.trans/meta.trans.other/aligned_union.pass.cpp |  4 +++-
 .../meta.trans/meta.trans.other/common_type.pass.cpp   |  4 +++-
 .../meta.trans/meta.trans.other/conditional.pass.cpp   |  4 +++-
 .../meta/meta.trans/meta.trans.other/decay.pass.cpp    |  4 +++-
 .../meta.trans/meta.trans.other/enable_if.fail.cpp     |  4 +++-
 .../meta.trans/meta.trans.other/enable_if.pass.cpp     |  4 +++-
 .../meta.trans/meta.trans.other/enable_if2.fail.cpp    |  4 +++-
 .../meta.trans/meta.trans.other/remove_cvref.pass.cpp  |  4 +++-
 .../meta.trans/meta.trans.other/result_of.pass.cpp     |  4 +++-
 .../meta.trans/meta.trans.other/result_of11.pass.cpp   |  4 +++-
 .../meta.trans/meta.trans.other/type_identity.pass.cpp |  4 +++-
 .../meta.trans.other/underlying_type.pass.cpp          |  4 +++-
 .../meta.trans/meta.trans.ptr/add_pointer.pass.cpp     |  4 +++-
 .../meta.trans/meta.trans.ptr/remove_pointer.pass.cpp  |  4 +++-
 .../meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp  |  4 +++-
 .../meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp  |  4 +++-
 .../meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp |  4 +++-
 .../meta.trans/meta.trans.sign/make_signed.pass.cpp    |  4 +++-
 .../meta.trans/meta.trans.sign/make_unsigned.pass.cpp  |  4 +++-
 .../utilities/meta/meta.trans/nothing_to_do.pass.cpp   |  4 +++-
 .../std/utilities/meta/meta.type.synop/endian.pass.cpp |  4 +++-
 .../meta/meta.type.synop/nothing_to_do.pass.cpp        |  4 +++-
 .../meta/meta.unary.prop.query/alignment_of.pass.cpp   |  4 +++-
 .../meta/meta.unary.prop.query/extent.pass.cpp         |  4 +++-
 .../utilities/meta/meta.unary.prop.query/rank.pass.cpp |  4 +++-
 .../meta/meta.unary.prop.query/void_t.pass.cpp         |  4 +++-
 .../void_t_feature_test_macro.pass.cpp                 |  4 +++-
 .../meta/meta.unary/meta.unary.cat/array.pass.cpp      |  4 +++-
 .../meta/meta.unary/meta.unary.cat/class.pass.cpp      |  4 +++-
 .../meta/meta.unary/meta.unary.cat/enum.pass.cpp       |  4 +++-
 .../meta.unary/meta.unary.cat/floating_point.pass.cpp  |  4 +++-
 .../meta/meta.unary/meta.unary.cat/function.pass.cpp   |  4 +++-
 .../meta/meta.unary/meta.unary.cat/integral.pass.cpp   |  4 +++-
 .../meta/meta.unary/meta.unary.cat/is_array.pass.cpp   |  4 +++-
 .../meta/meta.unary/meta.unary.cat/is_class.pass.cpp   |  4 +++-
 .../meta/meta.unary/meta.unary.cat/is_enum.pass.cpp    |  4 +++-
 .../meta.unary.cat/is_floating_point.pass.cpp          |  4 +++-
 .../meta.unary/meta.unary.cat/is_function.pass.cpp     |  4 +++-
 .../meta.unary/meta.unary.cat/is_integral.pass.cpp     |  4 +++-
 .../meta.unary.cat/is_lvalue_reference.pass.cpp        |  4 +++-
 .../meta.unary.cat/is_member_object_pointer.pass.cpp   |  4 +++-
 .../meta.unary.cat/is_member_pointer.pass.cpp          |  4 +++-
 .../meta.unary/meta.unary.cat/is_null_pointer.pass.cpp |  4 +++-
 .../meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp |  4 +++-
 .../meta.unary.cat/is_rvalue_reference.pass.cpp        |  4 +++-
 .../meta/meta.unary/meta.unary.cat/is_union.pass.cpp   |  4 +++-
 .../meta/meta.unary/meta.unary.cat/is_void.pass.cpp    |  4 +++-
 .../meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp |  4 +++-
 .../meta.unary.cat/member_function_pointer.pass.cpp    |  4 +++-
 .../member_function_pointer_no_variadics.pass.cpp      |  4 +++-
 .../meta.unary.cat/member_object_pointer.pass.cpp      |  4 +++-
 .../meta/meta.unary/meta.unary.cat/nullptr.pass.cpp    |  7 +++++--
 .../meta/meta.unary/meta.unary.cat/pointer.pass.cpp    |  4 +++-
 .../meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp |  4 +++-
 .../meta/meta.unary/meta.unary.cat/union.pass.cpp      |  4 +++-
 .../meta/meta.unary/meta.unary.cat/void.pass.cpp       |  4 +++-
 .../meta/meta.unary/meta.unary.comp/array.pass.cpp     |  4 +++-
 .../meta/meta.unary/meta.unary.comp/class.pass.cpp     |  4 +++-
 .../meta/meta.unary/meta.unary.comp/enum.pass.cpp      |  4 +++-
 .../meta.unary/meta.unary.comp/floating_point.pass.cpp |  4 +++-
 .../meta/meta.unary/meta.unary.comp/function.pass.cpp  |  4 +++-
 .../meta/meta.unary/meta.unary.comp/integral.pass.cpp  |  4 +++-
 .../meta.unary/meta.unary.comp/is_arithmetic.pass.cpp  |  4 +++-
 .../meta.unary/meta.unary.comp/is_compound.pass.cpp    |  4 +++-
 .../meta.unary/meta.unary.comp/is_fundamental.pass.cpp |  4 +++-
 .../meta.unary.comp/is_member_pointer.pass.cpp         |  4 +++-
 .../meta/meta.unary/meta.unary.comp/is_object.pass.cpp |  4 +++-
 .../meta.unary/meta.unary.comp/is_reference.pass.cpp   |  4 +++-
 .../meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp |  4 +++-
 .../meta.unary/meta.unary.comp/lvalue_ref.pass.cpp     |  4 +++-
 .../meta.unary.comp/member_function_pointer.pass.cpp   |  4 +++-
 .../meta.unary.comp/member_object_pointer.pass.cpp     |  4 +++-
 .../meta/meta.unary/meta.unary.comp/pointer.pass.cpp   |  4 +++-
 .../meta.unary/meta.unary.comp/rvalue_ref.pass.cpp     |  4 +++-
 .../meta/meta.unary/meta.unary.comp/union.pass.cpp     |  4 +++-
 .../meta/meta.unary/meta.unary.comp/void.pass.cpp      |  4 +++-
 .../has_unique_object_representations.pass.cpp         |  4 +++-
 .../meta.unary.prop/has_virtual_destructor.pass.cpp    |  4 +++-
 .../meta.unary/meta.unary.prop/is_abstract.pass.cpp    |  4 +++-
 .../meta.unary/meta.unary.prop/is_aggregate.pass.cpp   |  4 +++-
 .../meta.unary/meta.unary.prop/is_assignable.pass.cpp  |  4 +++-
 .../meta/meta.unary/meta.unary.prop/is_const.pass.cpp  |  4 +++-
 .../meta.unary.prop/is_constructible.pass.cpp          |  4 +++-
 .../meta.unary.prop/is_copy_assignable.pass.cpp        |  4 +++-
 .../meta.unary.prop/is_copy_constructible.pass.cpp     |  4 +++-
 .../meta.unary.prop/is_default_constructible.pass.cpp  |  4 +++-
 .../meta.unary.prop/is_destructible.pass.cpp           |  4 +++-
 .../meta/meta.unary/meta.unary.prop/is_empty.pass.cpp  |  4 +++-
 .../meta/meta.unary/meta.unary.prop/is_final.pass.cpp  |  4 +++-
 .../meta.unary.prop/is_literal_type.pass.cpp           |  4 +++-
 .../meta.unary.prop/is_move_assignable.pass.cpp        |  4 +++-
 .../meta.unary.prop/is_move_constructible.pass.cpp     |  4 +++-
 .../meta.unary.prop/is_nothrow_assignable.pass.cpp     |  4 +++-
 .../meta.unary.prop/is_nothrow_constructible.pass.cpp  |  4 +++-
 .../is_nothrow_copy_assignable.pass.cpp                |  4 +++-
 .../is_nothrow_copy_constructible.pass.cpp             |  4 +++-
 .../is_nothrow_default_constructible.pass.cpp          |  4 +++-
 .../meta.unary.prop/is_nothrow_destructible.pass.cpp   |  4 +++-
 .../is_nothrow_move_assignable.pass.cpp                |  4 +++-
 .../is_nothrow_move_constructible.pass.cpp             |  4 +++-
 .../meta.unary.prop/is_nothrow_swappable.pass.cpp      |  4 +++-
 .../meta.unary.prop/is_nothrow_swappable_with.pass.cpp |  4 +++-
 .../meta/meta.unary/meta.unary.prop/is_pod.pass.cpp    |  4 +++-
 .../meta.unary/meta.unary.prop/is_polymorphic.pass.cpp |  4 +++-
 .../meta/meta.unary/meta.unary.prop/is_signed.pass.cpp |  4 +++-
 .../meta.unary.prop/is_standard_layout.pass.cpp        |  4 +++-
 .../meta.unary/meta.unary.prop/is_swappable.pass.cpp   |  4 +++-
 .../is_swappable_include_order.pass.cpp                |  4 +++-
 .../meta.unary.prop/is_swappable_with.pass.cpp         |  4 +++-
 .../meta.unary/meta.unary.prop/is_trivial.pass.cpp     |  4 +++-
 .../meta.unary.prop/is_trivially_assignable.pass.cpp   |  4 +++-
 .../is_trivially_constructible.pass.cpp                |  4 +++-
 .../is_trivially_copy_assignable.pass.cpp              |  4 +++-
 .../is_trivially_copy_constructible.pass.cpp           |  4 +++-
 .../meta.unary.prop/is_trivially_copyable.pass.cpp     |  4 +++-
 .../is_trivially_default_constructible.pass.cpp        |  4 +++-
 .../meta.unary.prop/is_trivially_destructible.pass.cpp |  4 +++-
 .../is_trivially_move_assignable.pass.cpp              |  4 +++-
 .../is_trivially_move_constructible.pass.cpp           |  4 +++-
 .../meta.unary/meta.unary.prop/is_unsigned.pass.cpp    |  4 +++-
 .../meta.unary/meta.unary.prop/is_volatile.pass.cpp    |  4 +++-
 .../utilities/meta/meta.unary/nothing_to_do.pass.cpp   |  4 +++-
 test/std/utilities/nothing_to_do.pass.cpp              |  4 +++-
 .../optional.bad_optional_access/default.pass.cpp      |  4 +++-
 .../optional.bad_optional_access/derive.pass.cpp       |  4 +++-
 .../optional/optional.comp_with_t/equal.pass.cpp       |  4 +++-
 .../optional/optional.comp_with_t/greater.pass.cpp     |  4 +++-
 .../optional.comp_with_t/greater_equal.pass.cpp        |  4 +++-
 .../optional/optional.comp_with_t/less_equal.pass.cpp  |  4 +++-
 .../optional/optional.comp_with_t/less_than.pass.cpp   |  4 +++-
 .../optional/optional.comp_with_t/not_equal.pass.cpp   |  4 +++-
 .../optional/optional.hash/enabled_hash.pass.cpp       |  4 +++-
 .../std/utilities/optional/optional.hash/hash.pass.cpp |  4 +++-
 .../utilities/optional/optional.nullops/equal.pass.cpp |  4 +++-
 .../optional/optional.nullops/greater.pass.cpp         |  4 +++-
 .../optional/optional.nullops/greater_equal.pass.cpp   |  4 +++-
 .../optional/optional.nullops/less_equal.pass.cpp      |  4 +++-
 .../optional/optional.nullops/less_than.pass.cpp       |  4 +++-
 .../optional/optional.nullops/not_equal.pass.cpp       |  4 +++-
 .../optional/optional.nullopt/nullopt_t.fail.cpp       |  4 +++-
 .../optional/optional.nullopt/nullopt_t.pass.cpp       |  4 +++-
 .../optional.object.assign/assign_value.pass.cpp       |  4 +++-
 .../optional.object.assign/const_optional_U.pass.cpp   |  4 +++-
 .../optional.object.assign/copy.pass.cpp               |  4 +++-
 .../optional.object.assign/emplace.pass.cpp            |  4 +++-
 .../emplace_initializer_list.pass.cpp                  |  4 +++-
 .../optional.object.assign/move.pass.cpp               |  3 ++-
 .../optional.object.assign/nullopt_t.pass.cpp          |  4 +++-
 .../optional.object.assign/optional_U.pass.cpp         |  4 +++-
 .../optional.object/optional.object.ctor/U.pass.cpp    |  4 +++-
 .../optional.object.ctor/const_T.pass.cpp              |  4 +++-
 .../optional.object.ctor/const_optional_U.pass.cpp     |  4 +++-
 .../optional.object/optional.object.ctor/copy.pass.cpp |  4 +++-
 .../optional.object.ctor/deduct.fail.cpp               |  4 +++-
 .../optional.object.ctor/deduct.pass.cpp               |  4 +++-
 .../optional.object.ctor/default.pass.cpp              |  4 +++-
 .../explicit_const_optional_U.pass.cpp                 |  4 +++-
 .../optional.object.ctor/explicit_optional_U.pass.cpp  |  4 +++-
 .../optional.object.ctor/in_place_t.pass.cpp           |  4 +++-
 .../optional.object.ctor/initializer_list.pass.cpp     |  4 +++-
 .../optional.object/optional.object.ctor/move.fail.cpp |  4 +++-
 .../optional.object/optional.object.ctor/move.pass.cpp |  4 +++-
 .../optional.object.ctor/nullopt_t.pass.cpp            |  4 +++-
 .../optional.object.ctor/optional_U.pass.cpp           |  4 +++-
 .../optional.object.ctor/rvalue_T.pass.cpp             |  4 +++-
 .../optional.object/optional.object.dtor/dtor.pass.cpp |  4 +++-
 .../optional.object/optional.object.mod/reset.pass.cpp |  4 +++-
 .../optional.object.observe/bool.pass.cpp              |  4 +++-
 .../optional.object.observe/dereference.pass.cpp       |  4 +++-
 .../optional.object.observe/dereference_const.pass.cpp |  4 +++-
 .../dereference_const_rvalue.pass.cpp                  |  4 +++-
 .../dereference_rvalue.pass.cpp                        |  4 +++-
 .../optional.object.observe/has_value.pass.cpp         |  4 +++-
 .../optional.object.observe/op_arrow.pass.cpp          |  4 +++-
 .../optional.object.observe/op_arrow_const.pass.cpp    |  4 +++-
 .../optional.object.observe/value.pass.cpp             |  4 +++-
 .../optional.object.observe/value_const.fail.cpp       |  4 +++-
 .../optional.object.observe/value_const.pass.cpp       |  4 +++-
 .../value_const_rvalue.pass.cpp                        |  4 +++-
 .../optional.object.observe/value_or.pass.cpp          |  4 +++-
 .../optional.object.observe/value_or_const.pass.cpp    |  4 +++-
 .../optional.object.observe/value_rvalue.pass.cpp      |  4 +++-
 .../optional.object/optional.object.swap/swap.pass.cpp |  4 +++-
 .../optional_requires_destructible_object.fail.cpp     |  4 +++-
 .../optional/optional.object/special_members.pass.cpp  |  3 ++-
 .../optional/optional.object/triviality.pass.cpp       |  3 ++-
 .../utilities/optional/optional.object/types.pass.cpp  |  4 +++-
 .../utilities/optional/optional.relops/equal.pass.cpp  |  4 +++-
 .../optional/optional.relops/greater_equal.pass.cpp    |  4 +++-
 .../optional/optional.relops/greater_than.pass.cpp     |  4 +++-
 .../optional/optional.relops/less_equal.pass.cpp       |  4 +++-
 .../optional/optional.relops/less_than.pass.cpp        |  4 +++-
 .../optional/optional.relops/not_equal.pass.cpp        |  4 +++-
 .../optional/optional.specalg/make_optional.pass.cpp   |  4 +++-
 .../optional.specalg/make_optional_explicit.pass.cpp   |  4 +++-
 .../make_optional_explicit_initializer_list.pass.cpp   |  4 +++-
 .../utilities/optional/optional.specalg/swap.pass.cpp  |  4 +++-
 .../optional/optional.syn/optional_in_place_t.fail.cpp |  4 +++-
 .../optional_includes_initializer_list.pass.cpp        |  4 +++-
 .../optional/optional.syn/optional_nullopt_t.fail.cpp  |  4 +++-
 .../ratio/ratio.arithmetic/ratio_add.fail.cpp          |  4 +++-
 .../ratio/ratio.arithmetic/ratio_add.pass.cpp          |  4 +++-
 .../ratio/ratio.arithmetic/ratio_divide.fail.cpp       |  4 +++-
 .../ratio/ratio.arithmetic/ratio_divide.pass.cpp       |  4 +++-
 .../ratio/ratio.arithmetic/ratio_multiply.fail.cpp     |  4 +++-
 .../ratio/ratio.arithmetic/ratio_multiply.pass.cpp     |  4 +++-
 .../ratio/ratio.arithmetic/ratio_subtract.fail.cpp     |  4 +++-
 .../ratio/ratio.arithmetic/ratio_subtract.pass.cpp     |  4 +++-
 .../ratio/ratio.comparison/ratio_equal.pass.cpp        |  4 +++-
 .../ratio/ratio.comparison/ratio_greater.pass.cpp      |  4 +++-
 .../ratio.comparison/ratio_greater_equal.pass.cpp      |  4 +++-
 .../ratio/ratio.comparison/ratio_less.pass.cpp         |  4 +++-
 .../ratio/ratio.comparison/ratio_less_equal.pass.cpp   |  4 +++-
 .../ratio/ratio.comparison/ratio_not_equal.pass.cpp    |  4 +++-
 test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp    |  4 +++-
 test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp   |  4 +++-
 test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp   |  4 +++-
 test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp   |  4 +++-
 .../utilities/ratio/ratio.si/nothing_to_do.pass.cpp    |  4 +++-
 test/std/utilities/ratio/typedefs.pass.cpp             |  4 +++-
 .../smartptr/unique.ptr/nothing_to_do.pass.cpp         |  4 +++-
 .../unique.ptr/unique.ptr.class/pointer_type.pass.cpp  |  4 +++-
 .../unique.ptr.class/unique.ptr.asgn/move.pass.cpp     |  4 +++-
 .../unique.ptr.asgn/move_convert.pass.cpp              |  4 +++-
 .../unique.ptr.asgn/move_convert.runtime.pass.cpp      |  4 +++-
 .../unique.ptr.asgn/move_convert.single.pass.cpp       |  4 +++-
 .../unique.ptr.class/unique.ptr.asgn/null.pass.cpp     |  4 +++-
 .../unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp  |  4 +++-
 .../unique.ptr.ctor/auto_pointer.pass.cpp              |  4 +++-
 .../unique.ptr.class/unique.ptr.ctor/default.pass.cpp  |  4 +++-
 .../unique.ptr.class/unique.ptr.ctor/move.pass.cpp     |  4 +++-
 .../unique.ptr.ctor/move_convert.pass.cpp              |  4 +++-
 .../unique.ptr.ctor/move_convert.runtime.pass.cpp      |  4 +++-
 .../unique.ptr.ctor/move_convert.single.pass.cpp       |  4 +++-
 .../unique.ptr.class/unique.ptr.ctor/null.pass.cpp     |  4 +++-
 .../unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp  |  4 +++-
 .../unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp  |  4 +++-
 .../unique.ptr.ctor/pointer_deleter.fail.cpp           |  4 +++-
 .../unique.ptr.ctor/pointer_deleter.pass.cpp           |  4 +++-
 .../unique.ptr.class/unique.ptr.dtor/null.pass.cpp     |  4 +++-
 .../unique.ptr.modifiers/release.pass.cpp              |  4 +++-
 .../unique.ptr.modifiers/reset.pass.cpp                |  4 +++-
 .../unique.ptr.modifiers/reset.runtime.fail.cpp        |  4 +++-
 .../unique.ptr.modifiers/reset.single.pass.cpp         |  4 +++-
 .../unique.ptr.modifiers/reset_self.pass.cpp           |  4 +++-
 .../unique.ptr.modifiers/swap.pass.cpp                 |  4 +++-
 .../unique.ptr.observers/dereference.runtime.fail.cpp  |  4 +++-
 .../unique.ptr.observers/dereference.single.pass.cpp   |  4 +++-
 .../unique.ptr.observers/explicit_bool.pass.cpp        |  4 +++-
 .../unique.ptr.class/unique.ptr.observers/get.pass.cpp |  4 +++-
 .../unique.ptr.observers/get_deleter.pass.cpp          |  4 +++-
 .../unique.ptr.observers/op_arrow.runtime.fail.cpp     |  4 +++-
 .../unique.ptr.observers/op_arrow.single.pass.cpp      |  4 +++-
 .../unique.ptr.observers/op_subscript.runtime.pass.cpp |  4 +++-
 .../unique.ptr.observers/op_subscript.single.fail.cpp  |  4 +++-
 .../unique.ptr.create/make_unique.array.pass.cpp       |  4 +++-
 .../unique.ptr.create/make_unique.array1.fail.cpp      |  4 +++-
 .../unique.ptr.create/make_unique.array2.fail.cpp      |  4 +++-
 .../unique.ptr.create/make_unique.array3.fail.cpp      |  4 +++-
 .../unique.ptr.create/make_unique.array4.fail.cpp      |  4 +++-
 .../unique.ptr.create/make_unique.single.pass.cpp      |  4 +++-
 .../unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp  |  4 +++-
 .../unique.ptr.dltr.dflt/convert_ctor.pass.cpp         |  4 +++-
 .../unique.ptr.dltr.dflt/default.pass.cpp              |  4 +++-
 .../unique.ptr.dltr.dflt/incomplete.fail.cpp           |  4 +++-
 .../unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp |  4 +++-
 .../unique.ptr.dltr.dflt1/convert_ctor.fail.cpp        |  4 +++-
 .../unique.ptr.dltr.dflt1/convert_ctor.pass.cpp        |  4 +++-
 .../unique.ptr.dltr.dflt1/default.pass.cpp             |  4 +++-
 .../unique.ptr.dltr.dflt1/incomplete.fail.cpp          |  4 +++-
 .../unique.ptr.dltr.general/nothing_to_do.pass.cpp     |  4 +++-
 .../unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp |  4 +++-
 .../smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp |  4 +++-
 .../unique.ptr/unique.ptr.special/rel.pass.cpp         |  4 +++-
 .../unique.ptr/unique.ptr.special/swap.pass.cpp        |  4 +++-
 .../template.bitset/bitset.cons/char_ptr_ctor.pass.cpp |  4 +++-
 .../template.bitset/bitset.cons/default.pass.cpp       |  4 +++-
 .../template.bitset/bitset.cons/string_ctor.pass.cpp   |  4 +++-
 .../template.bitset/bitset.cons/ull_ctor.pass.cpp      |  4 +++-
 .../template.bitset/bitset.hash/bitset.pass.cpp        |  4 +++-
 .../template.bitset/bitset.hash/enabled_hash.pass.cpp  |  4 +++-
 .../template.bitset/bitset.members/all.pass.cpp        |  4 +++-
 .../template.bitset/bitset.members/any.pass.cpp        |  4 +++-
 .../template.bitset/bitset.members/count.pass.cpp      |  4 +++-
 .../template.bitset/bitset.members/flip_all.pass.cpp   |  4 +++-
 .../template.bitset/bitset.members/flip_one.pass.cpp   |  4 +++-
 .../template.bitset/bitset.members/index.pass.cpp      |  4 +++-
 .../bitset.members/index_const.pass.cpp                |  4 +++-
 .../template.bitset/bitset.members/left_shift.pass.cpp |  4 +++-
 .../bitset.members/left_shift_eq.pass.cpp              |  4 +++-
 .../template.bitset/bitset.members/none.pass.cpp       |  4 +++-
 .../template.bitset/bitset.members/not_all.pass.cpp    |  4 +++-
 .../template.bitset/bitset.members/op_and_eq.pass.cpp  |  4 +++-
 .../template.bitset/bitset.members/op_eq_eq.pass.cpp   |  4 +++-
 .../template.bitset/bitset.members/op_or_eq.pass.cpp   |  4 +++-
 .../template.bitset/bitset.members/op_xor_eq.pass.cpp  |  4 +++-
 .../template.bitset/bitset.members/reset_all.pass.cpp  |  4 +++-
 .../template.bitset/bitset.members/reset_one.pass.cpp  |  4 +++-
 .../bitset.members/right_shift.pass.cpp                |  4 +++-
 .../bitset.members/right_shift_eq.pass.cpp             |  4 +++-
 .../template.bitset/bitset.members/set_all.pass.cpp    |  4 +++-
 .../template.bitset/bitset.members/set_one.pass.cpp    |  4 +++-
 .../template.bitset/bitset.members/size.pass.cpp       |  4 +++-
 .../template.bitset/bitset.members/test.pass.cpp       |  4 +++-
 .../template.bitset/bitset.members/to_string.pass.cpp  |  4 +++-
 .../template.bitset/bitset.members/to_ullong.pass.cpp  |  4 +++-
 .../template.bitset/bitset.members/to_ulong.pass.cpp   |  4 +++-
 .../template.bitset/bitset.operators/op_and.pass.cpp   |  4 +++-
 .../template.bitset/bitset.operators/op_not.pass.cpp   |  4 +++-
 .../template.bitset/bitset.operators/op_or.pass.cpp    |  4 +++-
 .../bitset.operators/stream_in.pass.cpp                |  4 +++-
 .../bitset.operators/stream_out.pass.cpp               |  4 +++-
 test/std/utilities/template.bitset/includes.pass.cpp   |  4 +++-
 test/std/utilities/time/date.time/ctime.pass.cpp       |  4 +++-
 test/std/utilities/time/days.pass.cpp                  |  4 +++-
 test/std/utilities/time/hours.pass.cpp                 |  4 +++-
 test/std/utilities/time/microseconds.pass.cpp          |  4 +++-
 test/std/utilities/time/milliseconds.pass.cpp          |  4 +++-
 test/std/utilities/time/minutes.pass.cpp               |  4 +++-
 test/std/utilities/time/months.pass.cpp                |  4 +++-
 test/std/utilities/time/nanoseconds.pass.cpp           |  4 +++-
 test/std/utilities/time/seconds.pass.cpp               |  4 +++-
 .../std/utilities/time/time.cal/nothing_to_do.pass.cpp |  4 +++-
 .../time.cal.day/time.cal.day.members/ctor.pass.cpp    |  4 +++-
 .../time.cal.day.members/decrement.pass.cpp            |  4 +++-
 .../time.cal.day.members/increment.pass.cpp            |  4 +++-
 .../time.cal.day/time.cal.day.members/ok.pass.cpp      |  4 +++-
 .../time.cal.day.members/plus_minus_equal.pass.cpp     |  4 +++-
 .../time.cal.day.nonmembers/comparisons.pass.cpp       |  4 +++-
 .../time.cal.day.nonmembers/literals.fail.cpp          |  4 +++-
 .../time.cal.day.nonmembers/literals.pass.cpp          |  4 +++-
 .../time.cal.day.nonmembers/minus.pass.cpp             |  4 +++-
 .../time.cal.day/time.cal.day.nonmembers/plus.pass.cpp |  4 +++-
 .../time.cal.day.nonmembers/streaming.pass.cpp         |  4 +++-
 .../time/time.cal/time.cal.day/types.pass.cpp          |  4 +++-
 .../time/time.cal/time.cal.last/types.pass.cpp         |  4 +++-
 .../time.cal.md/time.cal.md.members/ctor.pass.cpp      |  4 +++-
 .../time.cal.md/time.cal.md.members/day.pass.cpp       |  4 +++-
 .../time.cal.md/time.cal.md.members/month.pass.cpp     |  4 +++-
 .../time.cal.md/time.cal.md.members/ok.pass.cpp        |  4 +++-
 .../time.cal.md.nonmembers/comparisons.pass.cpp        |  4 +++-
 .../time.cal.md.nonmembers/streaming.pass.cpp          |  4 +++-
 .../utilities/time/time.cal/time.cal.md/types.pass.cpp |  4 +++-
 .../time/time.cal/time.cal.mdlast/comparisons.pass.cpp |  4 +++-
 .../time/time.cal/time.cal.mdlast/ctor.pass.cpp        |  4 +++-
 .../time/time.cal/time.cal.mdlast/month.pass.cpp       |  4 +++-
 .../time/time.cal/time.cal.mdlast/ok.pass.cpp          |  4 +++-
 .../time/time.cal/time.cal.mdlast/streaming.pass.cpp   |  4 +++-
 .../time/time.cal/time.cal.mdlast/types.pass.cpp       |  4 +++-
 .../time.cal.month.members/ctor.pass.cpp               |  4 +++-
 .../time.cal.month.members/decrement.pass.cpp          |  4 +++-
 .../time.cal.month.members/increment.pass.cpp          |  4 +++-
 .../time.cal.month/time.cal.month.members/ok.pass.cpp  |  4 +++-
 .../time.cal.month.members/plus_minus_equal.pass.cpp   |  4 +++-
 .../time.cal.month.nonmembers/comparisons.pass.cpp     |  4 +++-
 .../time.cal.month.nonmembers/literals.pass.cpp        |  4 +++-
 .../time.cal.month.nonmembers/minus.pass.cpp           |  4 +++-
 .../time.cal.month.nonmembers/plus.pass.cpp            |  4 +++-
 .../time.cal.month.nonmembers/streaming.pass.cpp       |  4 +++-
 .../time/time.cal/time.cal.month/types.pass.cpp        |  4 +++-
 .../time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp    |  4 +++-
 .../time.cal.mwd/time.cal.mwd.members/month.pass.cpp   |  4 +++-
 .../time.cal.mwd/time.cal.mwd.members/ok.pass.cpp      |  4 +++-
 .../time.cal.mwd.members/weekday_indexed.pass.cpp      |  4 +++-
 .../time.cal.mwd.nonmembers/comparisons.pass.cpp       |  4 +++-
 .../time.cal.mwd.nonmembers/streaming.pass.cpp         |  4 +++-
 .../time/time.cal/time.cal.mwd/types.pass.cpp          |  4 +++-
 .../time.cal.mwdlast.members/ctor.pass.cpp             |  4 +++-
 .../time.cal.mwdlast.members/month.pass.cpp            |  4 +++-
 .../time.cal.mwdlast.members/ok.pass.cpp               |  4 +++-
 .../time.cal.mwdlast.members/weekday_last.pass.cpp     |  4 +++-
 .../time.cal.mwdlast.nonmembers/comparisons.pass.cpp   |  4 +++-
 .../time.cal.mwdlast.nonmembers/streaming.pass.cpp     |  4 +++-
 .../time/time.cal/time.cal.mwdlast/types.pass.cpp      |  4 +++-
 .../time.cal/time.cal.operators/month_day.pass.cpp     |  4 +++-
 .../time.cal.operators/month_day_last.pass.cpp         |  4 +++-
 .../time.cal/time.cal.operators/month_weekday.pass.cpp |  4 +++-
 .../time.cal.operators/month_weekday_last.pass.cpp     |  4 +++-
 .../time.cal/time.cal.operators/year_month.pass.cpp    |  4 +++-
 .../time.cal.operators/year_month_day.pass.cpp         |  4 +++-
 .../time.cal.operators/year_month_day_last.pass.cpp    |  4 +++-
 .../time.cal.operators/year_month_weekday.pass.cpp     |  4 +++-
 .../year_month_weekday_last.pass.cpp                   |  4 +++-
 .../time.cal.wdidx.members/ctor.pass.cpp               |  4 +++-
 .../time.cal.wdidx.members/index.pass.cpp              |  4 +++-
 .../time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp  |  4 +++-
 .../time.cal.wdidx.members/weekday.pass.cpp            |  4 +++-
 .../time.cal.wdidx.nonmembers/comparisons.pass.cpp     |  4 +++-
 .../time.cal.wdidx.nonmembers/streaming.pass.cpp       |  4 +++-
 .../time/time.cal/time.cal.wdidx/types.pass.cpp        |  4 +++-
 .../time.cal.wdlast.members/ctor.pass.cpp              |  4 +++-
 .../time.cal.wdlast.members/ok.pass.cpp                |  4 +++-
 .../time.cal.wdlast.members/weekday.pass.cpp           |  4 +++-
 .../time.cal.wdlast.nonmembers/comparisons.pass.cpp    |  4 +++-
 .../time.cal.wdlast.nonmembers/streaming.pass.cpp      |  4 +++-
 .../time/time.cal/time.cal.wdlast/types.pass.cpp       |  4 +++-
 .../time.cal.weekday.members/ctor.local_days.pass.cpp  |  4 +++-
 .../time.cal.weekday.members/ctor.pass.cpp             |  4 +++-
 .../time.cal.weekday.members/ctor.sys_days.pass.cpp    |  4 +++-
 .../time.cal.weekday.members/decrement.pass.cpp        |  4 +++-
 .../time.cal.weekday.members/increment.pass.cpp        |  4 +++-
 .../time.cal.weekday.members/ok.pass.cpp               |  4 +++-
 .../time.cal.weekday.members/operator[].pass.cpp       |  4 +++-
 .../time.cal.weekday.members/plus_minus_equal.pass.cpp |  4 +++-
 .../time.cal.weekday.nonmembers/comparisons.pass.cpp   |  4 +++-
 .../time.cal.weekday.nonmembers/literals.pass.cpp      |  4 +++-
 .../time.cal.weekday.nonmembers/minus.pass.cpp         |  4 +++-
 .../time.cal.weekday.nonmembers/plus.pass.cpp          |  4 +++-
 .../time.cal.weekday.nonmembers/streaming.pass.cpp     |  4 +++-
 .../time/time.cal/time.cal.weekday/types.pass.cpp      |  4 +++-
 .../time.cal.year/time.cal.year.members/ctor.pass.cpp  |  4 +++-
 .../time.cal.year.members/decrement.pass.cpp           |  4 +++-
 .../time.cal.year.members/increment.pass.cpp           |  4 +++-
 .../time.cal.year.members/is_leap.pass.cpp             |  4 +++-
 .../time.cal.year/time.cal.year.members/ok.pass.cpp    |  4 +++-
 .../time.cal.year.members/plus_minus.pass.cpp          |  4 +++-
 .../time.cal.year.members/plus_minus_equal.pass.cpp    |  4 +++-
 .../time.cal.year.nonmembers/comparisons.pass.cpp      |  4 +++-
 .../time.cal.year.nonmembers/literals.fail.cpp         |  4 +++-
 .../time.cal.year.nonmembers/literals.pass.cpp         |  4 +++-
 .../time.cal.year.nonmembers/minus.pass.cpp            |  4 +++-
 .../time.cal.year.nonmembers/plus.pass.cpp             |  4 +++-
 .../time.cal.year.nonmembers/streaming.pass.cpp        |  4 +++-
 .../time/time.cal/time.cal.year/types.pass.cpp         |  4 +++-
 .../time.cal.ym/time.cal.ym.members/ctor.pass.cpp      |  4 +++-
 .../time.cal.ym/time.cal.ym.members/month.pass.cpp     |  4 +++-
 .../time.cal.ym/time.cal.ym.members/ok.pass.cpp        |  4 +++-
 .../plus_minus_equal_month.pass.cpp                    |  4 +++-
 .../time.cal.ym.members/plus_minus_equal_year.pass.cpp |  4 +++-
 .../time.cal.ym/time.cal.ym.members/year.pass.cpp      |  4 +++-
 .../time.cal.ym.nonmembers/comparisons.pass.cpp        |  4 +++-
 .../time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp  |  4 +++-
 .../time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp   |  4 +++-
 .../time.cal.ym.nonmembers/streaming.pass.cpp          |  4 +++-
 .../utilities/time/time.cal/time.cal.ym/types.pass.cpp |  4 +++-
 .../time.cal.ymd.members/ctor.local_days.pass.cpp      |  4 +++-
 .../time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp    |  4 +++-
 .../time.cal.ymd.members/ctor.sys_days.pass.cpp        |  4 +++-
 .../ctor.year_month_day_last.pass.cpp                  |  4 +++-
 .../time.cal.ymd/time.cal.ymd.members/day.pass.cpp     |  4 +++-
 .../time.cal.ymd/time.cal.ymd.members/month.pass.cpp   |  4 +++-
 .../time.cal.ymd/time.cal.ymd.members/ok.pass.cpp      |  4 +++-
 .../time.cal.ymd.members/op.local_days.pass.cpp        |  3 ++-
 .../time.cal.ymd.members/op.sys_days.pass.cpp          |  3 ++-
 .../plus_minus_equal_month.pass.cpp                    |  4 +++-
 .../plus_minus_equal_year.pass.cpp                     |  4 +++-
 .../time.cal.ymd/time.cal.ymd.members/year.pass.cpp    |  4 +++-
 .../time.cal.ymd.nonmembers/comparisons.pass.cpp       |  4 +++-
 .../time.cal.ymd.nonmembers/minus.pass.cpp             |  4 +++-
 .../time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp |  4 +++-
 .../time.cal.ymd.nonmembers/streaming.pass.cpp         |  4 +++-
 .../time/time.cal/time.cal.ymd/types.pass.cpp          |  4 +++-
 .../time.cal.ymdlast.members/ctor.pass.cpp             |  4 +++-
 .../time.cal.ymdlast.members/day.pass.cpp              |  4 +++-
 .../time.cal.ymdlast.members/month.pass.cpp            |  4 +++-
 .../time.cal.ymdlast.members/month_day_last.pass.cpp   |  4 +++-
 .../time.cal.ymdlast.members/ok.pass.cpp               |  4 +++-
 .../time.cal.ymdlast.members/op_local_days.pass.cpp    |  4 +++-
 .../time.cal.ymdlast.members/op_sys_days.pass.cpp      |  4 +++-
 .../plus_minus_equal_month.pass.cpp                    |  4 +++-
 .../plus_minus_equal_year.pass.cpp                     |  4 +++-
 .../time.cal.ymdlast.members/year.pass.cpp             |  4 +++-
 .../time.cal.ymdlast.nonmembers/comparisons.pass.cpp   |  4 +++-
 .../time.cal.ymdlast.nonmembers/minus.pass.cpp         |  4 +++-
 .../time.cal.ymdlast.nonmembers/plus.pass.cpp          |  4 +++-
 .../time.cal.ymdlast.nonmembers/streaming.pass.cpp     |  4 +++-
 .../time.cal.ymwd.members/ctor.local_days.pass.cpp     |  4 +++-
 .../time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp  |  4 +++-
 .../time.cal.ymwd.members/ctor.sys_days.pass.cpp       |  4 +++-
 .../time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp |  4 +++-
 .../time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp |  4 +++-
 .../time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp    |  4 +++-
 .../time.cal.ymwd.members/op.local_days.pass.cpp       |  3 ++-
 .../time.cal.ymwd.members/op.sys_days.pass.cpp         |  3 ++-
 .../plus_minus_equal_month.pass.cpp                    |  4 +++-
 .../plus_minus_equal_year.pass.cpp                     |  4 +++-
 .../time.cal.ymwd.members/weekday.pass.cpp             |  4 +++-
 .../time.cal.ymwd.members/weekday_indexed.pass.cpp     |  4 +++-
 .../time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp  |  4 +++-
 .../time.cal.ymwd.nonmembers/comparisons.pass.cpp      |  4 +++-
 .../time.cal.ymwd.nonmembers/minus.pass.cpp            |  4 +++-
 .../time.cal.ymwd.nonmembers/plus.pass.cpp             |  4 +++-
 .../time.cal.ymwd.nonmembers/streaming.pass.cpp        |  4 +++-
 .../time/time.cal/time.cal.ymwd/types.pass.cpp         |  4 +++-
 .../time.cal.ymwdlast.members/ctor.pass.cpp            |  4 +++-
 .../time.cal.ymwdlast.members/month.pass.cpp           |  4 +++-
 .../time.cal.ymwdlast.members/ok.pass.cpp              |  4 +++-
 .../time.cal.ymwdlast.members/op_local_days.pass.cpp   |  4 +++-
 .../time.cal.ymwdlast.members/op_sys_days.pass.cpp     |  4 +++-
 .../plus_minus_equal_month.pass.cpp                    |  4 +++-
 .../plus_minus_equal_year.pass.cpp                     |  4 +++-
 .../time.cal.ymwdlast.members/weekday.pass.cpp         |  4 +++-
 .../time.cal.ymwdlast.members/year.pass.cpp            |  4 +++-
 .../time.cal.ymwdlast.nonmembers/comparisons.pass.cpp  |  4 +++-
 .../time.cal.ymwdlast.nonmembers/minus.pass.cpp        |  4 +++-
 .../time.cal.ymwdlast.nonmembers/plus.pass.cpp         |  4 +++-
 .../time.cal.ymwdlast.nonmembers/streaming.pass.cpp    |  4 +++-
 .../time/time.cal/time.cal.ymwdlast/types.pass.cpp     |  4 +++-
 .../time/time.clock.req/nothing_to_do.pass.cpp         |  4 +++-
 .../utilities/time/time.clock/nothing_to_do.pass.cpp   |  4 +++-
 .../time.clock/time.clock.file/consistency.pass.cpp    |  4 +++-
 .../time/time.clock/time.clock.file/file_time.pass.cpp |  4 +++-
 .../time/time.clock/time.clock.file/now.pass.cpp       |  4 +++-
 .../time.clock/time.clock.file/rep_signed.pass.cpp     |  4 +++-
 .../time.clock/time.clock.hires/consistency.pass.cpp   |  4 +++-
 .../time/time.clock/time.clock.hires/now.pass.cpp      |  4 +++-
 .../time.clock/time.clock.steady/consistency.pass.cpp  |  4 +++-
 .../time/time.clock/time.clock.steady/now.pass.cpp     |  4 +++-
 .../time.clock/time.clock.system/consistency.pass.cpp  |  4 +++-
 .../time.clock/time.clock.system/from_time_t.pass.cpp  |  4 +++-
 .../time.clock.system/local_time.types.pass.cpp        |  4 +++-
 .../time/time.clock/time.clock.system/now.pass.cpp     |  4 +++-
 .../time.clock/time.clock.system/rep_signed.pass.cpp   |  4 +++-
 .../time.clock.system/sys.time.types.pass.cpp          |  4 +++-
 .../time.clock/time.clock.system/to_time_t.pass.cpp    |  4 +++-
 .../time/time.duration/default_ratio.pass.cpp          |  4 +++-
 .../std/utilities/time/time.duration/duration.fail.cpp |  4 +++-
 .../utilities/time/time.duration/positive_num.fail.cpp |  4 +++-
 test/std/utilities/time/time.duration/ratio.fail.cpp   |  4 +++-
 .../time/time.duration/time.duration.alg/abs.fail.cpp  |  4 +++-
 .../time/time.duration/time.duration.alg/abs.pass.cpp  |  4 +++-
 .../time.duration.arithmetic/op_++.pass.cpp            |  4 +++-
 .../time.duration.arithmetic/op_++int.pass.cpp         |  4 +++-
 .../time.duration.arithmetic/op_+.pass.cpp             |  4 +++-
 .../time.duration.arithmetic/op_+=.pass.cpp            |  4 +++-
 .../time.duration.arithmetic/op_--.pass.cpp            |  4 +++-
 .../time.duration.arithmetic/op_--int.pass.cpp         |  4 +++-
 .../time.duration.arithmetic/op_-.pass.cpp             |  4 +++-
 .../time.duration.arithmetic/op_-=.pass.cpp            |  4 +++-
 .../time.duration.arithmetic/op_divide=.pass.cpp       |  4 +++-
 .../time.duration.arithmetic/op_mod=duration.pass.cpp  |  4 +++-
 .../time.duration.arithmetic/op_mod=rep.pass.cpp       |  4 +++-
 .../time.duration.arithmetic/op_times=.pass.cpp        |  4 +++-
 .../time.duration/time.duration.cast/ceil.fail.cpp     |  4 +++-
 .../time.duration/time.duration.cast/ceil.pass.cpp     |  4 +++-
 .../time.duration.cast/duration_cast.pass.cpp          |  4 +++-
 .../time.duration/time.duration.cast/floor.fail.cpp    |  4 +++-
 .../time.duration/time.duration.cast/floor.pass.cpp    |  4 +++-
 .../time.duration/time.duration.cast/round.fail.cpp    |  4 +++-
 .../time.duration/time.duration.cast/round.pass.cpp    |  4 +++-
 .../time.duration.cast/toduration.fail.cpp             |  4 +++-
 .../time.duration.comparisons/op_equal.pass.cpp        |  4 +++-
 .../time.duration.comparisons/op_less.pass.cpp         |  4 +++-
 .../time.duration.cons/convert_exact.pass.cpp          |  4 +++-
 .../time.duration.cons/convert_float_to_int.fail.cpp   |  4 +++-
 .../time.duration.cons/convert_inexact.fail.cpp        |  4 +++-
 .../time.duration.cons/convert_inexact.pass.cpp        |  4 +++-
 .../time.duration.cons/convert_int_to_float.pass.cpp   |  4 +++-
 .../time.duration.cons/convert_overflow.pass.cpp       |  4 +++-
 .../time.duration/time.duration.cons/default.pass.cpp  |  4 +++-
 .../time/time.duration/time.duration.cons/rep.pass.cpp |  4 +++-
 .../time.duration/time.duration.cons/rep01.fail.cpp    |  4 +++-
 .../time.duration/time.duration.cons/rep02.fail.cpp    |  4 +++-
 .../time.duration/time.duration.cons/rep02.pass.cpp    |  4 +++-
 .../time.duration/time.duration.cons/rep03.fail.cpp    |  4 +++-
 .../time.duration.literals/literals.pass.cpp           |  4 +++-
 .../time.duration.literals/literals1.fail.cpp          |  4 +++-
 .../time.duration.literals/literals1.pass.cpp          |  4 +++-
 .../time.duration.literals/literals2.fail.cpp          |  4 +++-
 .../time.duration.literals/literals2.pass.cpp          |  4 +++-
 .../time.duration.nonmember/op_+.pass.cpp              |  4 +++-
 .../time.duration.nonmember/op_-.pass.cpp              |  4 +++-
 .../op_divide_duration.pass.cpp                        |  4 +++-
 .../time.duration.nonmember/op_divide_rep.fail.cpp     |  4 +++-
 .../time.duration.nonmember/op_divide_rep.pass.cpp     |  4 +++-
 .../time.duration.nonmember/op_mod_duration.pass.cpp   |  4 +++-
 .../time.duration.nonmember/op_mod_rep.fail.cpp        |  4 +++-
 .../time.duration.nonmember/op_mod_rep.pass.cpp        |  4 +++-
 .../time.duration.nonmember/op_times_rep.pass.cpp      |  4 +++-
 .../time.duration.nonmember/op_times_rep1.fail.cpp     |  4 +++-
 .../time.duration.nonmember/op_times_rep2.fail.cpp     |  4 +++-
 .../time.duration.observer/tested_elsewhere.pass.cpp   |  4 +++-
 .../time.duration/time.duration.special/max.pass.cpp   |  4 +++-
 .../time.duration/time.duration.special/min.pass.cpp   |  4 +++-
 .../time.duration/time.duration.special/zero.pass.cpp  |  4 +++-
 test/std/utilities/time/time.duration/types.pass.cpp   |  4 +++-
 .../time/time.point/default_duration.pass.cpp          |  4 +++-
 test/std/utilities/time/time.point/duration.fail.cpp   |  4 +++-
 .../time.point/time.point.arithmetic/op_+=.pass.cpp    |  4 +++-
 .../time.point/time.point.arithmetic/op_-=.pass.cpp    |  4 +++-
 .../time/time.point/time.point.cast/ceil.fail.cpp      |  4 +++-
 .../time/time.point/time.point.cast/ceil.pass.cpp      |  4 +++-
 .../time/time.point/time.point.cast/floor.fail.cpp     |  4 +++-
 .../time/time.point/time.point.cast/floor.pass.cpp     |  4 +++-
 .../time/time.point/time.point.cast/round.fail.cpp     |  4 +++-
 .../time/time.point/time.point.cast/round.pass.cpp     |  4 +++-
 .../time.point.cast/time_point_cast.pass.cpp           |  4 +++-
 .../time.point/time.point.cast/toduration.fail.cpp     |  4 +++-
 .../time.point.comparisons/op_equal.fail.cpp           |  4 +++-
 .../time.point.comparisons/op_equal.pass.cpp           |  4 +++-
 .../time.point/time.point.comparisons/op_less.fail.cpp |  4 +++-
 .../time.point/time.point.comparisons/op_less.pass.cpp |  4 +++-
 .../time/time.point/time.point.cons/convert.fail.cpp   |  4 +++-
 .../time/time.point/time.point.cons/convert.pass.cpp   |  4 +++-
 .../time/time.point/time.point.cons/default.pass.cpp   |  4 +++-
 .../time/time.point/time.point.cons/duration.fail.cpp  |  4 +++-
 .../time/time.point/time.point.cons/duration.pass.cpp  |  4 +++-
 .../time/time.point/time.point.nonmember/op_+.pass.cpp |  4 +++-
 .../time.point.nonmember/op_-duration.pass.cpp         |  4 +++-
 .../time.point.nonmember/op_-time_point.pass.cpp       |  4 +++-
 .../time.point.observer/tested_elsewhere.pass.cpp      |  4 +++-
 .../time/time.point/time.point.special/max.pass.cpp    |  4 +++-
 .../time/time.point/time.point.special/min.pass.cpp    |  4 +++-
 .../utilities/time/time.traits/nothing_to_do.pass.cpp  |  4 +++-
 .../time.traits.duration_values/max.pass.cpp           |  4 +++-
 .../time.traits.duration_values/min.pass.cpp           |  4 +++-
 .../time.traits.duration_values/zero.pass.cpp          |  4 +++-
 .../time.traits.is_fp/treat_as_floating_point.pass.cpp |  4 +++-
 .../time.traits.specializations/duration.pass.cpp      |  4 +++-
 .../time.traits.specializations/time_point.pass.cpp    |  4 +++-
 test/std/utilities/time/weeks.pass.cpp                 |  4 +++-
 test/std/utilities/time/years.pass.cpp                 |  4 +++-
 test/std/utilities/tuple/tuple.general/ignore.pass.cpp |  4 +++-
 .../tuple/tuple.general/tuple.smartptr.pass.cpp        |  4 +++-
 .../utilities/tuple/tuple.tuple/TupleFunction.pass.cpp |  6 ++++--
 .../tuple/tuple.tuple/tuple.apply/apply.pass.cpp       |  4 +++-
 .../tuple.apply/apply_extended_types.pass.cpp          |  4 +++-
 .../tuple.tuple/tuple.apply/apply_large_arity.pass.cpp |  4 +++-
 .../tuple.tuple/tuple.apply/make_from_tuple.pass.cpp   |  4 +++-
 .../tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp |  4 +++-
 .../tuple.tuple/tuple.assign/convert_copy.pass.cpp     |  4 +++-
 .../tuple.tuple/tuple.assign/convert_move.pass.cpp     |  4 +++-
 .../tuple/tuple.tuple/tuple.assign/copy.fail.cpp       |  4 +++-
 .../tuple/tuple.tuple/tuple.assign/copy.pass.cpp       |  4 +++-
 .../tuple/tuple.tuple/tuple.assign/move.pass.cpp       |  4 +++-
 .../tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp  |  4 +++-
 .../tuple.assign/tuple_array_template_depth.pass.cpp   |  4 +++-
 .../PR20855_tuple_ref_binding_diagnostics.pass.cpp     |  4 +++-
 .../PR22806_constrain_tuple_like_ctor.pass.cpp         |  4 +++-
 .../tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp |  4 +++-
 .../PR27684_contains_ref_to_incomplete_type.pass.cpp   |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp     |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp      |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp      |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp       |  4 +++-
 .../tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp      |  4 +++-
 .../tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp |  4 +++-
 .../tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp |  4 +++-
 .../tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp  |  4 +++-
 .../tuple.cnstr/alloc_convert_copy.fail.cpp            |  4 +++-
 .../tuple.cnstr/alloc_convert_copy.pass.cpp            |  4 +++-
 .../tuple.cnstr/alloc_convert_move.fail.cpp            |  4 +++-
 .../tuple.cnstr/alloc_convert_move.pass.cpp            |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp  |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp  |  4 +++-
 .../tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp   |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp |  4 +++-
 .../tuple.tuple/tuple.cnstr/const_Types2.fail.cpp      |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp  |  4 +++-
 .../tuple.tuple/tuple.cnstr/convert_copy.pass.cpp      |  4 +++-
 .../tuple.tuple/tuple.cnstr/convert_move.pass.cpp      |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp        |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp        |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/default.pass.cpp     |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp        |  4 +++-
 .../tuple.cnstr/implicit_deduction_guides.pass.cpp     |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/move.pass.cpp        |  4 +++-
 .../tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp   |  4 +++-
 .../tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp  |  4 +++-
 .../tuple.cnstr/tuple_array_template_depth.pass.cpp    |  4 +++-
 .../tuple.creation/forward_as_tuple.pass.cpp           |  4 +++-
 .../tuple.tuple/tuple.creation/make_tuple.pass.cpp     |  4 +++-
 .../tuple/tuple.tuple/tuple.creation/tie.pass.cpp      |  4 +++-
 .../tuple.tuple/tuple.creation/tuple_cat.pass.cpp      |  4 +++-
 .../tuple/tuple.tuple/tuple.elem/get_const.fail.cpp    |  4 +++-
 .../tuple/tuple.tuple/tuple.elem/get_const.pass.cpp    |  4 +++-
 .../tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp |  4 +++-
 .../tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp |  4 +++-
 .../tuple.tuple/tuple.elem/get_non_const.pass.cpp      |  4 +++-
 .../tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp       |  4 +++-
 .../tuple.tuple/tuple.elem/tuple.by.type.fail.cpp      |  4 +++-
 .../tuple.tuple/tuple.elem/tuple.by.type.pass.cpp      |  4 +++-
 .../tuple.helper/tuple.include.array.pass.cpp          |  4 +++-
 .../tuple.helper/tuple.include.utility.pass.cpp        |  4 +++-
 .../tuple.tuple/tuple.helper/tuple_element.fail.cpp    |  4 +++-
 .../tuple.tuple/tuple.helper/tuple_element.pass.cpp    |  4 +++-
 .../tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp |  4 +++-
 .../tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp |  4 +++-
 .../tuple.helper/tuple_size_incomplete.fail.cpp        |  4 +++-
 .../tuple.helper/tuple_size_incomplete.pass.cpp        |  4 +++-
 .../tuple_size_structured_bindings.pass.cpp            |  4 +++-
 .../tuple.tuple/tuple.helper/tuple_size_v.fail.cpp     |  4 +++-
 .../tuple.tuple/tuple.helper/tuple_size_v.pass.cpp     |  4 +++-
 .../tuple.helper/tuple_size_value_sfinae.pass.cpp      |  4 +++-
 .../utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp  |  4 +++-
 .../utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp  |  4 +++-
 .../tuple.tuple/tuple.special/non_member_swap.pass.cpp |  4 +++-
 .../tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp  |  4 +++-
 .../tuple.tuple/tuple.traits/uses_allocator.pass.cpp   |  4 +++-
 .../type.index/type.index.hash/enabled_hash.pass.cpp   |  4 +++-
 .../utilities/type.index/type.index.hash/hash.pass.cpp |  4 +++-
 .../type.index/type.index.members/ctor.pass.cpp        |  4 +++-
 .../type.index/type.index.members/eq.pass.cpp          |  4 +++-
 .../type.index/type.index.members/hash_code.pass.cpp   |  4 +++-
 .../type.index/type.index.members/lt.pass.cpp          |  4 +++-
 .../type.index/type.index.members/name.pass.cpp        |  4 +++-
 .../type.index.overview/copy_assign.pass.cpp           |  4 +++-
 .../type.index/type.index.overview/copy_ctor.pass.cpp  |  4 +++-
 .../type.index.synopsis/hash_type_index.pass.cpp       |  4 +++-
 .../utilities/utilities.general/nothing_to_do.pass.cpp |  4 +++-
 .../allocator.requirements/nothing_to_do.pass.cpp      |  4 +++-
 .../hash.requirements/nothing_to_do.pass.cpp           |  4 +++-
 .../utility.requirements/nothing_to_do.pass.cpp        |  4 +++-
 .../nothing_to_do.pass.cpp                             |  4 +++-
 .../swappable.requirements/nothing_to_do.pass.cpp      |  4 +++-
 .../utility.arg.requirements/nothing_to_do.pass.cpp    |  4 +++-
 test/std/utilities/utility/as_const/as_const.fail.cpp  |  4 +++-
 test/std/utilities/utility/as_const/as_const.pass.cpp  |  4 +++-
 test/std/utilities/utility/declval/declval.pass.cpp    |  4 +++-
 test/std/utilities/utility/exchange/exchange.pass.cpp  |  4 +++-
 test/std/utilities/utility/forward/forward.fail.cpp    |  4 +++-
 test/std/utilities/utility/forward/forward.pass.cpp    |  4 +++-
 test/std/utilities/utility/forward/forward_03.pass.cpp |  4 +++-
 test/std/utilities/utility/forward/move.fail.cpp       |  4 +++-
 test/std/utilities/utility/forward/move.pass.cpp       |  4 +++-
 .../utility/forward/move_if_noexcept.pass.cpp          |  4 +++-
 test/std/utilities/utility/operators/rel_ops.pass.cpp  |  4 +++-
 .../std/utilities/utility/pairs/nothing_to_do.pass.cpp |  4 +++-
 .../utility/pairs/pair.astuple/get_const.fail.cpp      |  4 +++-
 .../utility/pairs/pair.astuple/get_const.pass.cpp      |  4 +++-
 .../utility/pairs/pair.astuple/get_const_rv.pass.cpp   |  4 +++-
 .../utility/pairs/pair.astuple/get_non_const.pass.cpp  |  4 +++-
 .../utility/pairs/pair.astuple/get_rv.pass.cpp         |  4 +++-
 .../utility/pairs/pair.astuple/pairs.by.type.pass.cpp  |  4 +++-
 .../utility/pairs/pair.astuple/pairs.by.type1.fail.cpp |  4 +++-
 .../utility/pairs/pair.astuple/pairs.by.type2.fail.cpp |  4 +++-
 .../utility/pairs/pair.astuple/pairs.by.type3.fail.cpp |  4 +++-
 .../utility/pairs/pair.astuple/tuple_element.fail.cpp  |  4 +++-
 .../utility/pairs/pair.astuple/tuple_element.pass.cpp  |  4 +++-
 .../utility/pairs/pair.astuple/tuple_size.pass.cpp     |  4 +++-
 .../pairs/pair.piecewise/piecewise_construct.pass.cpp  |  4 +++-
 .../utility/pairs/pairs.general/nothing_to_do.pass.cpp |  4 +++-
 .../utilities/utility/pairs/pairs.pair/U_V.pass.cpp    |  4 +++-
 .../pairs/pairs.pair/assign_const_pair_U_V.pass.cpp    |  4 +++-
 .../utility/pairs/pairs.pair/assign_pair.pass.cpp      |  4 +++-
 .../pairs/pairs.pair/assign_pair_cxx03.pass.cpp        |  4 +++-
 .../utility/pairs/pairs.pair/assign_rv_pair.pass.cpp   |  4 +++-
 .../pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp       |  4 +++-
 .../pairs/pairs.pair/const_first_const_second.pass.cpp |  4 +++-
 .../pairs.pair/const_first_const_second_cxx03.pass.cpp |  4 +++-
 .../utility/pairs/pairs.pair/const_pair_U_V.pass.cpp   |  4 +++-
 .../pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp     |  4 +++-
 .../utility/pairs/pairs.pair/copy_ctor.pass.cpp        |  4 +++-
 .../utility/pairs/pairs.pair/default-sfinae.pass.cpp   |  4 +++-
 .../utility/pairs/pairs.pair/default.pass.cpp          |  4 +++-
 .../utilities/utility/pairs/pairs.pair/dtor.pass.cpp   |  4 +++-
 .../pairs.pair/implicit_deduction_guides.pass.cpp      |  4 +++-
 .../utility/pairs/pairs.pair/move_ctor.pass.cpp        |  4 +++-
 .../pairs/pairs.pair/not_constexpr_cxx11.fail.cpp      |  4 +++-
 .../utility/pairs/pairs.pair/piecewise.pass.cpp        |  4 +++-
 .../utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp      |  4 +++-
 .../pairs.pair/special_member_generation_test.pass.cpp |  4 +++-
 .../utilities/utility/pairs/pairs.pair/swap.pass.cpp   |  4 +++-
 .../pairs/pairs.pair/trivial_copy_move.pass.cpp        |  4 +++-
 .../utilities/utility/pairs/pairs.pair/types.pass.cpp  |  4 +++-
 .../utility/pairs/pairs.spec/comparison.pass.cpp       |  4 +++-
 .../utility/pairs/pairs.spec/make_pair.pass.cpp        |  4 +++-
 .../utility/pairs/pairs.spec/non_member_swap.pass.cpp  |  4 +++-
 test/std/utilities/utility/synopsis.pass.cpp           |  4 +++-
 .../utilities/utility/utility.inplace/inplace.pass.cpp |  4 +++-
 test/std/utilities/utility/utility.swap/swap.pass.cpp  |  4 +++-
 .../utilities/utility/utility.swap/swap_array.pass.cpp |  4 +++-
 .../bad_variant_access.pass.cpp                        |  4 +++-
 .../variant/variant.general/nothing_to_do.pass.cpp     |  4 +++-
 .../variant/variant.get/get_if_index.pass.cpp          |  4 +++-
 .../utilities/variant/variant.get/get_if_type.pass.cpp |  4 +++-
 .../utilities/variant/variant.get/get_index.pass.cpp   |  4 +++-
 .../utilities/variant/variant.get/get_type.pass.cpp    |  4 +++-
 .../variant/variant.get/holds_alternative.pass.cpp     |  4 +++-
 .../variant/variant.hash/enabled_hash.pass.cpp         |  4 +++-
 test/std/utilities/variant/variant.hash/hash.pass.cpp  |  4 +++-
 .../variant.helpers/variant_alternative.fail.cpp       |  4 +++-
 .../variant.helpers/variant_alternative.pass.cpp       |  4 +++-
 .../variant/variant.helpers/variant_size.pass.cpp      |  4 +++-
 .../variant/variant.monostate.relops/relops.pass.cpp   |  4 +++-
 .../variant/variant.monostate/monostate.pass.cpp       |  4 +++-
 .../utilities/variant/variant.relops/relops.pass.cpp   |  4 +++-
 .../variant/variant.relops/relops_bool_conv.fail.cpp   |  4 +++-
 .../variant/variant.synopsis/variant_npos.pass.cpp     |  4 +++-
 .../variant/variant.variant/variant.assign/T.pass.cpp  |  4 +++-
 .../variant.variant/variant.assign/copy.pass.cpp       |  4 +++-
 .../variant.variant/variant.assign/move.pass.cpp       |  4 +++-
 .../variant/variant.variant/variant.ctor/T.pass.cpp    |  4 +++-
 .../variant/variant.variant/variant.ctor/copy.pass.cpp |  4 +++-
 .../variant.variant/variant.ctor/default.pass.cpp      |  4 +++-
 .../variant.ctor/in_place_index_args.pass.cpp          |  4 +++-
 .../in_place_index_init_list_args.pass.cpp             |  4 +++-
 .../variant.ctor/in_place_type_args.pass.cpp           |  4 +++-
 .../variant.ctor/in_place_type_init_list_args.pass.cpp |  4 +++-
 .../variant/variant.variant/variant.ctor/move.pass.cpp |  4 +++-
 .../variant/variant.variant/variant.dtor/dtor.pass.cpp |  4 +++-
 .../variant.mod/emplace_index_args.pass.cpp            |  4 +++-
 .../variant.mod/emplace_index_init_list_args.pass.cpp  |  4 +++-
 .../variant.mod/emplace_type_args.pass.cpp             |  4 +++-
 .../variant.mod/emplace_type_init_list_args.pass.cpp   |  4 +++-
 .../variant.variant/variant.status/index.pass.cpp      |  4 +++-
 .../variant.status/valueless_by_exception.pass.cpp     |  4 +++-
 .../variant/variant.variant/variant.swap/swap.pass.cpp |  4 +++-
 .../variant/variant.variant/variant_array.fail.cpp     |  4 +++-
 .../variant/variant.variant/variant_empty.fail.cpp     |  4 +++-
 .../variant/variant.variant/variant_reference.fail.cpp |  4 +++-
 .../variant/variant.variant/variant_void.fail.cpp      |  4 +++-
 .../std/utilities/variant/variant.visit/visit.pass.cpp |  4 +++-
 test/support/nothing_to_do.pass.cpp                    |  4 +++-
 .../test.support/test_convertible_header.pass.cpp      |  4 +++-
 test/support/test.support/test_demangle.pass.cpp       |  4 +++-
 .../test_macros_header_exceptions.fail.cpp             |  4 +++-
 .../test_macros_header_exceptions.pass.cpp             |  4 +++-
 .../test.support/test_macros_header_rtti.fail.cpp      |  4 +++-
 .../test.support/test_macros_header_rtti.pass.cpp      |  4 +++-
 .../test.support/test_poisoned_hash_helper.pass.cpp    |  4 +++-
 .../c1xx_broken_is_trivially_copyable.pass.cpp         |  4 +++-
 .../c1xx_broken_za_ctor_check.pass.cpp                 |  4 +++-
 utils/generate_feature_test_macro_components.py        |  2 +-
 6123 files changed, 18208 insertions(+), 6227 deletions(-)

diff --git a/cmake/Modules/CheckLibcxxAtomic.cmake b/cmake/Modules/CheckLibcxxAtomic.cmake
index 98862d423..1e6e5e637 100644
--- a/cmake/Modules/CheckLibcxxAtomic.cmake
+++ b/cmake/Modules/CheckLibcxxAtomic.cmake
@@ -24,7 +24,7 @@ function(check_cxx_atomics varname)
 #include <atomic>
 std::atomic<uintptr_t> x;
 std::atomic<uintmax_t> y;
-int main() {
+int main(int, char**) {
   return x + y;
 }
 " ${varname})
diff --git a/docs/DesignDocs/DebugMode.rst b/docs/DesignDocs/DebugMode.rst
index 3b997d446..1ce438d53 100644
--- a/docs/DesignDocs/DebugMode.rst
+++ b/docs/DesignDocs/DebugMode.rst
@@ -53,7 +53,7 @@ assertion handler as follows:
 
   #define _LIBCPP_DEBUG 1
   #include <string>
-  int main() {
+  int main(int, char**) {
     std::__libcpp_debug_function = std::__libcpp_throw_debug_function;
     try {
       std::string::iterator bad_it;
diff --git a/docs/DesignDocs/FileTimeType.rst b/docs/DesignDocs/FileTimeType.rst
index 488ff174b..f1e9edd87 100644
--- a/docs/DesignDocs/FileTimeType.rst
+++ b/docs/DesignDocs/FileTimeType.rst
@@ -119,7 +119,7 @@ to throw in cases where the user was confident the call should succeed. (See bel
     set_file_times("/tmp/foo", new_times); // OK, supported by most FSes
   }
 
-  int main() {
+  int main(int, char**) {
     path p = "/tmp/foo";
     file_status st = status(p);
     if (!exists(st) || !is_regular_file(st))
@@ -128,6 +128,7 @@ to throw in cases where the user was confident the call should succeed. (See bel
       return 1;
     // It seems reasonable to assume this call should succeed.
     file_time_type tp = last_write_time(p); // BAD! Throws value_too_large.
+    return 0;
   }
 
 
diff --git a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
index 926ee40f0..0b55ae950 100644
--- a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
+++ b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
@@ -39,10 +39,12 @@ struct gen
 };
 
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v;
     std::random_shuffle(v.begin(), v.end());
     gen r;
     std::random_shuffle(v.begin(), v.end(), r);
+
+  return 0;
 }
diff --git a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
index aca87ffb3..7c187edae 100644
--- a/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
+++ b/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
@@ -40,10 +40,12 @@ struct gen
 };
 
 
-int main()
+int main(int, char**)
 {
     int v[1] = {1};
     std::random_shuffle(&v[0], &v[1]); // expected-error{{'random_shuffle<int *>' is deprecated}}
     gen r;
     std::random_shuffle(&v[0], &v[1], r); // expected-error{{'random_shuffle<int *, gen &>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/libcxx/algorithms/debug_less.pass.cpp b/test/libcxx/algorithms/debug_less.pass.cpp
index f5b2796fd..247e07f06 100644
--- a/test/libcxx/algorithms/debug_less.pass.cpp
+++ b/test/libcxx/algorithms/debug_less.pass.cpp
@@ -210,8 +210,10 @@ void test_upper_and_lower_bound() {
     }
 }
 
-int main() {
+int main(int, char**) {
     test_passing();
     test_failing();
     test_upper_and_lower_bound();
+
+  return 0;
 }
diff --git a/test/libcxx/algorithms/half_positive.pass.cpp b/test/libcxx/algorithms/half_positive.pass.cpp
index 1434b3e9a..ec2d57c9d 100644
--- a/test/libcxx/algorithms/half_positive.pass.cpp
+++ b/test/libcxx/algorithms/half_positive.pass.cpp
@@ -28,7 +28,7 @@ TEST_CONSTEXPR bool test(IntType max_v = IntType(std::numeric_limits<UnderlyingT
 
 }  // namespace
 
-int main()
+int main(int, char**)
 {
     {
         assert(test<char>());
@@ -52,4 +52,6 @@ int main()
 #endif  // !defined(_LIBCPP_HAS_NO_INT128)
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/libcxx/algorithms/version.pass.cpp b/test/libcxx/algorithms/version.pass.cpp
index 4fcd03674..e7d368789 100644
--- a/test/libcxx/algorithms/version.pass.cpp
+++ b/test/libcxx/algorithms/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/atomics/atomics.align/align.pass.sh.cpp b/test/libcxx/atomics/atomics.align/align.pass.sh.cpp
index 7162493c5..16badab84 100644
--- a/test/libcxx/atomics/atomics.align/align.pass.sh.cpp
+++ b/test/libcxx/atomics/atomics.align/align.pass.sh.cpp
@@ -35,7 +35,7 @@ template <typename T> struct atomic_test : public std::__atomic_base<T> {
   }
 };
 
-int main() {
+int main(int, char**) {
 
 // structs and unions can't be defined in the template invocation.
 // Work around this with a typedef.
@@ -89,4 +89,6 @@ int main() {
   CHECK_ALIGNMENT(struct LLIArr16 { long long int i[16]; });
   CHECK_ALIGNMENT(struct Padding { char c; /* padding */ long long int i; });
   CHECK_ALIGNMENT(union IntFloat { int i; float f; });
+
+  return 0;
 }
diff --git a/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp b/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
index 7006a86d4..2919fb666 100644
--- a/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
+++ b/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
@@ -27,7 +27,7 @@ X x;
 std::atomic_flag global = ATOMIC_FLAG_INIT;
 #endif
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     assert(global.test_and_set() == 1);
@@ -40,4 +40,6 @@ int main()
         std::atomic_flag f(true);
         assert(f.test_and_set() == 1);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp b/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
index 2869bf96e..7bc21851b 100644
--- a/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
+++ b/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
@@ -19,7 +19,7 @@
 
 #include <atomic>
 
-int main() {
+int main(int, char**) {
     std::atomic<int> x(42);
     volatile std::atomic<int>& vx = x;
     int val1 = 1; ((void)val1);
@@ -124,4 +124,6 @@ int main() {
         std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acquire);
         std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp b/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
index 27ae20929..6ee09e206 100644
--- a/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
+++ b/test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
@@ -18,6 +18,8 @@
 
 #include <atomic>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp b/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
index 41fbe2879..af2d55e1a 100644
--- a/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
+++ b/test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
@@ -12,6 +12,8 @@
    'libcpp-has-no-threads' is available iff _LIBCPP_HAS_NO_THREADS is defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/atomics/version.pass.cpp b/test/libcxx/atomics/version.pass.cpp
index 5d89bc575..48114a3e5 100644
--- a/test/libcxx/atomics/version.pass.cpp
+++ b/test/libcxx/atomics/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/map/version.pass.cpp b/test/libcxx/containers/associative/map/version.pass.cpp
index da33a03de..8a498c60d 100644
--- a/test/libcxx/containers/associative/map/version.pass.cpp
+++ b/test/libcxx/containers/associative/map/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/non_const_comparator.fail.cpp b/test/libcxx/containers/associative/non_const_comparator.fail.cpp
index 23c6ee8a2..432e7c08d 100644
--- a/test/libcxx/containers/associative/non_const_comparator.fail.cpp
+++ b/test/libcxx/containers/associative/non_const_comparator.fail.cpp
@@ -22,7 +22,7 @@ struct BadCompare {
   }
 };
 
-int main() {
+int main(int, char**) {
   static_assert(!std::__invokable<BadCompare const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadCompare&, int const&, int const&>::value, "");
 
@@ -44,4 +44,6 @@ int main() {
     using C = std::multimap<long, int, BadCompare>;
     C s;
   }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/set/version.pass.cpp b/test/libcxx/containers/associative/set/version.pass.cpp
index 57420bae4..b0d9abd6a 100644
--- a/test/libcxx/containers/associative/set/version.pass.cpp
+++ b/test/libcxx/containers/associative/set/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp b/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
index 8f17dbba7..e178a408f 100644
--- a/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
+++ b/test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
@@ -1608,11 +1608,13 @@ test5()
     assert(h.__is_black_ == true);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
     test5();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp b/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
index 3b5ba7d2a..12289c84a 100644
--- a/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
+++ b/test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
@@ -53,6 +53,8 @@ void testKeyValueTrait() {
   }
 }
 
-int main() {
+int main(int, char**) {
   testKeyValueTrait();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/tree_left_rotate.pass.cpp b/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
index c7f136c8c..5f775c3f6 100644
--- a/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
+++ b/test/libcxx/containers/associative/tree_left_rotate.pass.cpp
@@ -93,8 +93,10 @@ test2()
     assert(c.__right_ == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/tree_remove.pass.cpp b/test/libcxx/containers/associative/tree_remove.pass.cpp
index b2c814dd7..c3ec20c55 100644
--- a/test/libcxx/containers/associative/tree_remove.pass.cpp
+++ b/test/libcxx/containers/associative/tree_remove.pass.cpp
@@ -1641,10 +1641,12 @@ test4()
     assert(root.__is_black_ == false);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/tree_right_rotate.pass.cpp b/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
index bcaf71f0b..5332d7b16 100644
--- a/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
+++ b/test/libcxx/containers/associative/tree_right_rotate.pass.cpp
@@ -93,8 +93,10 @@ test2()
     assert(c.__right_ == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/associative/undef_min_max.pass.cpp b/test/libcxx/containers/associative/undef_min_max.pass.cpp
index 8ebd8a4ae..53dd87871 100644
--- a/test/libcxx/containers/associative/undef_min_max.pass.cpp
+++ b/test/libcxx/containers/associative/undef_min_max.pass.cpp
@@ -15,7 +15,9 @@
 
 #include <map>
 
-int main() {
+int main(int, char**) {
   std::map<int, int> m;
   ((void)m);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/container.adaptors/queue/version.pass.cpp b/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
index 87d907a5a..353c09179 100644
--- a/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
+++ b/test/libcxx/containers/container.adaptors/queue/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/container.adaptors/stack/version.pass.cpp b/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
index 00ed12c06..e8da8c52b 100644
--- a/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
+++ b/test/libcxx/containers/container.adaptors/stack/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp b/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
index 9470a9e31..12529e0f1 100644
--- a/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
+++ b/test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
@@ -17,9 +17,11 @@ namespace __gnu_cxx {
 template class hash_map<int, int>;
 }
 
-int main() {
+int main(int, char**) {
   typedef __gnu_cxx::hash_map<int, int> Map;
   Map m;
   Map m2(m);
   ((void)m2);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp b/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
index cd6cfeb0a..e4fa98863 100644
--- a/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
+++ b/test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
@@ -17,9 +17,11 @@ namespace __gnu_cxx {
 template class hash_set<int>;
 }
 
-int main() {
+int main(int, char**) {
   typedef __gnu_cxx::hash_set<int> Set;
   Set s;
   Set s2(s);
   ((void)s2);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp b/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
index 3f1084c47..3c3191166 100644
--- a/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
+++ b/test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
@@ -29,7 +29,7 @@ inline bool CheckDebugThrows(Array& Arr) {
   return false;
 }
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::array<int, 0> C;
@@ -45,4 +45,6 @@ int main()
     assert(CheckDebugThrows(c));
     assert(CheckDebugThrows(cc));
   }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp b/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
index 6fd053dd6..9f6f09f98 100644
--- a/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
+++ b/test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
@@ -29,7 +29,7 @@ inline bool CheckDebugThrows(Array& Arr) {
   return false;
 }
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::array<int, 0> C;
@@ -45,4 +45,6 @@ int main()
     assert(CheckDebugThrows(c));
     assert(CheckDebugThrows(cc));
   }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp b/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
index fadc22810..cb5e99b29 100644
--- a/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
+++ b/test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
@@ -29,7 +29,7 @@ inline bool CheckDebugThrows(Array& Arr, size_t Index) {
   return false;
 }
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::array<int, 0> C;
@@ -49,4 +49,6 @@ int main()
     assert(CheckDebugThrows(cc, 0));
     assert(CheckDebugThrows(cc, 1));
   }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/array/version.pass.cpp b/test/libcxx/containers/sequences/array/version.pass.cpp
index 21eb25764..29b15ad3e 100644
--- a/test/libcxx/containers/sequences/array/version.pass.cpp
+++ b/test/libcxx/containers/sequences/array/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/deque/incomplete.pass.cpp b/test/libcxx/containers/sequences/deque/incomplete.pass.cpp
index 3c5528d28..8179768d5 100644
--- a/test/libcxx/containers/sequences/deque/incomplete.pass.cpp
+++ b/test/libcxx/containers/sequences/deque/incomplete.pass.cpp
@@ -22,10 +22,12 @@ struct A {
   std::deque<A>::reverse_iterator it2;
 };
 
-int main()
+int main(int, char**)
 {
   A a;
   assert(a.d.size() == 0);
   a.it = a.d.begin();
   a.it2 = a.d.rend();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp b/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
index 2b87e53b9..169c0f72d 100644
--- a/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
+++ b/test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
@@ -16,10 +16,12 @@
 #include <deque>
 
 
-int main() {
+int main(int, char**) {
     std::deque<int> q;
     q.push_back(0);
     q.pop_back();
     q.pop_back();
     std::exit(1);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/deque/version.pass.cpp b/test/libcxx/containers/sequences/deque/version.pass.cpp
index 12256878a..8f05025f1 100644
--- a/test/libcxx/containers/sequences/deque/version.pass.cpp
+++ b/test/libcxx/containers/sequences/deque/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/forwardlist/version.pass.cpp b/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
index 7e61bde5c..cbe6d5821 100644
--- a/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
+++ b/test/libcxx/containers/sequences/forwardlist/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp b/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
index 62695f8f8..da0eb5ce0 100644
--- a/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::list<int> l1;
     l1.push_back(1); l1.push_back(2); l1.push_back(3);
@@ -27,4 +27,6 @@ int main()
     std::list<int> l2 = l1;
     l2.erase(i);
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp b/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
index 02306eb88..dcd05ec41 100644
--- a/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
@@ -25,10 +25,12 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::list<int> l1 = {1, 2, 3};
     std::list<int>::iterator i = l1.begin();
     std::list<int> l2 = std::move(l1);
     assert(*l2.erase(i) == 2);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
index 9554fd8bc..b570fef66 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
@@ -37,10 +37,12 @@ public:
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     std::list<A> c1;
     std::list<A> c2;
     std::list<A>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
index 6fa81ff47..c573bf7be 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
index 45d163a99..65cc4b8f8 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
@@ -28,4 +28,6 @@ int main()
     std::list<int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
index 5553221c1..971f2bd3f 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
@@ -20,12 +20,14 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
+
+  return 0;
 }
 
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
index 4ebe93b94..131529e5c 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
index a89ee5645..a9a35056a 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
index 60f9cf2e5..642ee4498 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
@@ -20,10 +20,12 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
index d3370b5de..c7c7f76b9 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v(100);
@@ -35,4 +35,6 @@ int main()
                                        input_iterator<const int*>(a+N));
         assert(false);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
index d51658473..10503bd9c 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
@@ -20,10 +20,12 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::list<int> v1(3);
     std::list<int> v2(3);
     v1.insert(v2.begin(), 4);
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
index 5bd20f7b6..7a658e394 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
@@ -20,10 +20,12 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::list<int> c1(100);
     std::list<int> c2;
     std::list<int>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
index 174425091..cdf01fe90 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
@@ -21,11 +21,13 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     std::list<int> v1(3);
     std::list<int> v2(3);
     int i = 4;
     v1.insert(v2.begin(), i);
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
index 4a292ff1f..8649f12a8 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {1, 2, 3};
     std::list<int> c(a, a+3);
@@ -32,4 +32,6 @@ int main()
     assert(c.empty());
     c.pop_back(); // operation under test
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
index 71882fd14..23323d8c6 100644
--- a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v1(3);
@@ -28,4 +28,6 @@ int main()
         v1.splice(v2.begin(), v2);
         assert(false);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
index cfaf10b51..37a206d2c 100644
--- a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v1(3);
@@ -28,4 +28,6 @@ int main()
         v1.splice(v1.begin(), v2, v1.begin());
         assert(false);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
index 9f48a7089..768c3d6f1 100644
--- a/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v1(3);
@@ -28,4 +28,6 @@ int main()
         v1.splice(v1.begin(), v2, v2.begin(), v1.end());
         assert(false);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/list/version.pass.cpp b/test/libcxx/containers/sequences/list/version.pass.cpp
index 92a1988cf..677c085b4 100644
--- a/test/libcxx/containers/sequences/list/version.pass.cpp
+++ b/test/libcxx/containers/sequences/list/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/vector/asan.pass.cpp b/test/libcxx/containers/sequences/vector/asan.pass.cpp
index bf29d9b14..866cce152 100644
--- a/test/libcxx/containers/sequences/vector/asan.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/asan.pass.cpp
@@ -28,7 +28,7 @@ void do_exit() {
   exit(0);
 }
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -68,5 +68,5 @@ int main()
     }
 }
 #else
-int main () { return 0; }
+int main(int, char**) { return 0; }
 #endif
diff --git a/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp b/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
index ce07bf778..443a6f2e9 100644
--- a/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
@@ -219,7 +219,7 @@ void test_resize_param() {
   assert(is_contiguous_container_asan_correct(v));
 }
 
-int main() {
+int main(int, char**) {
   test_push_back();
   test_emplace_back();
   test_insert_range();
@@ -230,4 +230,6 @@ int main() {
   test_insert_n2();
   test_resize();
   test_resize_param();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp b/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
index ffe8ca4ca..d3407e3aa 100644
--- a/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
@@ -15,7 +15,9 @@
 #include <vector>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::vector<const int> v = {1, 2, 3};
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/vector/db_back.pass.cpp b/test/libcxx/containers/sequences/vector/db_back.pass.cpp
index 21f19a9ec..3a35a086b 100644
--- a/test/libcxx/containers/sequences/vector/db_back.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_back.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_cback.pass.cpp b/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
index cc1a3d253..1c516ba57 100644
--- a/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cback.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -45,8 +45,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp b/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
index 83d9c00b2..1dc7211f2 100644
--- a/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -45,8 +45,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp b/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
index fc808eeb9..ceab50a86 100644
--- a/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_front.pass.cpp b/test/libcxx/containers/sequences/vector/db_front.pass.cpp
index df7bd35e0..a4aafcaef 100644
--- a/test/libcxx/containers/sequences/vector/db_front.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_front.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_index.pass.cpp b/test/libcxx/containers/sequences/vector/db_index.pass.cpp
index 5cb192548..a17ba2742 100644
--- a/test/libcxx/containers/sequences/vector/db_index.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_index.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
index d7222dd18..975b5e951 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
index d39d99c3c..0dcd6e7f2 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
index f868b755e..8d048f2fd 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
index c5039f9f8..19060da3d 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -53,8 +53,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
index ff60a05a4..13156c22f 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -51,8 +51,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
index 8249fd752..943c5209b 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -51,8 +51,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp b/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
index c619f20dd..39f26f668 100644
--- a/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp b/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
index 0ce185325..1d1e3a1ba 100644
--- a/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
@@ -16,10 +16,12 @@
 #include <vector>
 
 
-int main() {
+int main(int, char**) {
     std::vector<int> v;
     v.push_back(0);
     v.pop_back();
     v.pop_back();
     std::exit(1);
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index ee139c188..81263dec0 100644
--- a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -48,6 +48,8 @@ void test_ctor_under_alloc() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_under_alloc();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
index 37814b2f1..0100507ea 100644
--- a/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -51,6 +51,8 @@ void test_ctor_under_alloc() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_under_alloc();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/sequences/vector/version.pass.cpp b/test/libcxx/containers/sequences/vector/version.pass.cpp
index 16f45fc0b..93fd2e679 100644
--- a/test/libcxx/containers/sequences/vector/version.pass.cpp
+++ b/test/libcxx/containers/sequences/vector/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/unord/key_value_traits.pass.cpp b/test/libcxx/containers/unord/key_value_traits.pass.cpp
index c2d754b11..c5e420387 100644
--- a/test/libcxx/containers/unord/key_value_traits.pass.cpp
+++ b/test/libcxx/containers/unord/key_value_traits.pass.cpp
@@ -53,6 +53,8 @@ void testKeyValueTrait() {
   }
 }
 
-int main() {
+int main(int, char**) {
   testKeyValueTrait();
+
+  return 0;
 }
diff --git a/test/libcxx/containers/unord/next_pow2.pass.cpp b/test/libcxx/containers/unord/next_pow2.pass.cpp
index 36229dc24..2b4d02eec 100644
--- a/test/libcxx/containers/unord/next_pow2.pass.cpp
+++ b/test/libcxx/containers/unord/next_pow2.pass.cpp
@@ -74,7 +74,7 @@ fuzz_unordered_map_reserve(unsigned num_inserts,
     assert(m.bucket_count() >= num_reserve2);
 }
 
-int main()
+int main(int, char**)
 {
     test_next_pow2();
 
diff --git a/test/libcxx/containers/unord/next_prime.pass.cpp b/test/libcxx/containers/unord/next_prime.pass.cpp
index e049e451a..6a82ea1d6 100644
--- a/test/libcxx/containers/unord/next_prime.pass.cpp
+++ b/test/libcxx/containers/unord/next_prime.pass.cpp
@@ -36,7 +36,7 @@ is_prime(size_t n)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     assert(std::__next_prime(0) == 0);
     for (std::size_t n = 1; n <= 100000; ++n)
@@ -47,4 +47,6 @@ int main()
             assert(!is_prime(i));
         assert(is_prime(p));
     }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/unord/non_const_comparator.fail.cpp b/test/libcxx/containers/unord/non_const_comparator.fail.cpp
index 15fb8d4ed..8fa500e45 100644
--- a/test/libcxx/containers/unord/non_const_comparator.fail.cpp
+++ b/test/libcxx/containers/unord/non_const_comparator.fail.cpp
@@ -29,7 +29,7 @@ struct BadEqual {
   }
 };
 
-int main() {
+int main(int, char**) {
   static_assert(!std::__invokable<BadEqual const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadEqual&, int const&, int const&>::value, "");
 
@@ -54,4 +54,6 @@ int main() {
     using C = std::unordered_multimap<long, int, BadHash, BadEqual>;
     C s;
   }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp b/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
index 0206b998c..9ff6bafc3 100644
--- a/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -53,8 +53,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp b/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
index 79ddccd1f..ef383aa9f 100644
--- a/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp b/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
index 002dcd31a..5c2b4024a 100644
--- a/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -50,8 +50,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp b/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
index 887093b3c..8e76f1bda 100644
--- a/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -47,8 +47,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/containers/unord/unord.map/version.pass.cpp b/test/libcxx/containers/unord/unord.map/version.pass.cpp
index ce4a2784c..983acde54 100644
--- a/test/libcxx/containers/unord/unord.map/version.pass.cpp
+++ b/test/libcxx/containers/unord/unord.map/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp b/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
index 9ef240df8..af94748fd 100644
--- a/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
+++ b/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
@@ -42,7 +42,7 @@ struct GoodHashNoDefault {
   size_t operator()(T const&) const { return 0; }
 };
 
-int main() {
+int main(int, char**) {
 
   {
     using Set = std::unordered_set<VT>;
@@ -66,4 +66,6 @@ int main() {
     using Set = std::unordered_set<int, GoodHashNoDefault>;
     Set s(/*bucketcount*/42, GoodHashNoDefault(nullptr));
   }
+
+  return 0;
 }
diff --git a/test/libcxx/containers/unord/unord.set/version.pass.cpp b/test/libcxx/containers/unord/unord.set/version.pass.cpp
index 477867757..63144528c 100644
--- a/test/libcxx/containers/unord/unord.set/version.pass.cpp
+++ b/test/libcxx/containers/unord/unord.set/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp b/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
index e78e4ec76..d6c231527 100644
--- a/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
+++ b/test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
@@ -51,7 +51,7 @@ private:
   // FIXME Add tests here
 };
 
-int main()
+int main(int, char**)
 {
   using SetAlloc = test_allocator<int>;
   using MapAlloc = test_allocator<std::pair<const int, int>>;
@@ -66,4 +66,6 @@ int main()
     AssociativeContainerChecks<
         std::multimap<int, int, std::less<int>, MapAlloc>, CT_MultiMap>::run();
   }
+
+  return 0;
 }
diff --git a/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp b/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
index 94ad45b48..d05f9df3b 100644
--- a/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
+++ b/test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
@@ -307,7 +307,7 @@ private:
   }
 };
 
-int main()
+int main(int, char**)
 {
   using Alloc = test_allocator<int>;
   {
@@ -323,4 +323,6 @@ int main()
     SequenceContainerChecks<
         std::deque<int, Alloc>, CT_Deque>::run();
   }
+
+  return 0;
 }
diff --git a/test/libcxx/debug/containers/db_string.pass.cpp b/test/libcxx/debug/containers/db_string.pass.cpp
index e3b2b290d..b2812fca6 100644
--- a/test/libcxx/debug/containers/db_string.pass.cpp
+++ b/test/libcxx/debug/containers/db_string.pass.cpp
@@ -93,7 +93,9 @@ private:
   }
 };
 
-int main()
+int main(int, char**)
 {
   StringContainerChecks<>::run();
+
+  return 0;
 }
diff --git a/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp b/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
index 069c4ae21..8a6da0826 100644
--- a/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
+++ b/test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
@@ -49,7 +49,7 @@ private:
 
 };
 
-int main()
+int main(int, char**)
 {
   using SetAlloc = test_allocator<int>;
   using MapAlloc = test_allocator<std::pair<const int, int>>;
@@ -67,4 +67,6 @@ int main()
         std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, SetAlloc>,
         CT_UnorderedMultiSet>::run();
   }
+
+  return 0;
 }
diff --git a/test/libcxx/debug/debug_abort.pass.cpp b/test/libcxx/debug/debug_abort.pass.cpp
index a9dae6eea..270f2cb0f 100644
--- a/test/libcxx/debug/debug_abort.pass.cpp
+++ b/test/libcxx/debug/debug_abort.pass.cpp
@@ -27,7 +27,7 @@ void signal_handler(int signal)
     std::_Exit(EXIT_FAILURE);
 }
 
-int main()
+int main(int, char**)
 {
   if (std::signal(SIGABRT, signal_handler) != SIG_ERR)
     _LIBCPP_ASSERT(false, "foo");
diff --git a/test/libcxx/debug/debug_throw.pass.cpp b/test/libcxx/debug/debug_throw.pass.cpp
index c17546ebd..53e8538c4 100644
--- a/test/libcxx/debug/debug_throw.pass.cpp
+++ b/test/libcxx/debug/debug_throw.pass.cpp
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include <__debug>
 
-int main()
+int main(int, char**)
 {
   {
     std::__libcpp_debug_function = std::__libcpp_throw_debug_function;
@@ -37,4 +37,6 @@ int main()
                                   std::__libcpp_debug_exception
                   >::value), "must be an exception");
   }
+
+  return 0;
 }
diff --git a/test/libcxx/debug/debug_throw_register.pass.cpp b/test/libcxx/debug/debug_throw_register.pass.cpp
index 6d345f0ba..23b4091c3 100644
--- a/test/libcxx/debug/debug_throw_register.pass.cpp
+++ b/test/libcxx/debug/debug_throw_register.pass.cpp
@@ -26,10 +26,12 @@
 #include <__debug>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
   try {
     _LIBCPP_ASSERT(false, "foo");
     assert(false);
   } catch (...) {}
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
index 3b387b3ab..7f59ca202 100644
--- a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
+++ b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
@@ -22,7 +22,9 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::auto_ptr<int> p;
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
index be0ce6617..db4ac4aae 100644
--- a/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
+++ b/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
@@ -30,9 +30,11 @@
 #include <memory>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::auto_ptr<int> AP; // expected-error{{'auto_ptr<int>' is deprecated}}
     typedef std::auto_ptr<void> APV; // expected-error{{'auto_ptr<void>' is deprecated}}
     typedef std::auto_ptr_ref<int> APR; // expected-error{{'auto_ptr_ref<int>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp b/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
index 4009a5ce2..7a8399414 100644
--- a/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
index 4f035e014..07529aef2 100644
--- a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
@@ -14,8 +14,10 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp b/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
index 5b036ab41..24a104f5e 100644
--- a/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
@@ -39,4 +39,6 @@ extern "C" {
 #include <wctype.h>
 }
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp b/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
index 63f63ef59..ea117f6b2 100644
--- a/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
index 7252ab00a..835e2f216 100644
--- a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -14,10 +14,12 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     (void)cd;
     double x = sin(1.0);
     (void)x; // to placate scan-build
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp b/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
index 489fc874e..e26a75498 100644
--- a/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
+++ b/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
@@ -31,7 +31,7 @@ struct Foo {
     int identity(int v) { return v; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, int> PUF; // expected-error{{'pointer_to_unary_function<int, int>' is deprecated}}
     typedef std::pointer_to_binary_function<int, int, int> PBF; // expected-error{{'pointer_to_binary_function<int, int, int>' is deprecated}}
@@ -55,4 +55,6 @@ int main()
     std::mem_fun_ref<int, Foo, int>(&Foo::identity); // expected-error{{'mem_fun_ref<int, Foo, int>' is deprecated}}
     std::mem_fun_ref<int, Foo>(&Foo::const_zero); // expected-error{{'mem_fun_ref<int, Foo>' is deprecated}}
     std::mem_fun_ref<int, Foo, int>(&Foo::const_identity); // expected-error{{'mem_fun_ref<int, Foo, int>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
index 5ea562628..7b759d04b 100644
--- a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
+++ b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
@@ -30,7 +30,7 @@ struct Foo {
   int sum(int a, int b) const { return a + b; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, int> PUF;
     typedef std::pointer_to_binary_function<int, int, int> PBF;
@@ -60,4 +60,6 @@ int main()
 
     assert((std::mem_fun_ref(&Foo::zero)(f) == 0));
     assert((std::mem_fun_ref(&Foo::identity)(f, 5) == 5));
+
+  return 0;
 }
diff --git a/test/libcxx/depr/depr.str.strstreams/version.pass.cpp b/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
index 9d6b9762e..148f233ce 100644
--- a/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
+++ b/test/libcxx/depr/depr.str.strstreams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp b/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
index bd1ee604c..2065b2b4e 100644
--- a/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
+++ b/test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
@@ -21,5 +21,7 @@
 #error _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR must be defined
 #endif
 
-int main() {
+int main(int, char**) {
+
+  return 0;
 }
diff --git a/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp b/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
index 4d49440fc..ca14271f0 100644
--- a/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
+++ b/test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
@@ -23,7 +23,7 @@ void f3()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
 
     std::unexpected_handler old = std::get_unexpected();
@@ -38,4 +38,6 @@ int main()
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
diff --git a/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp b/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
index 43836f4fb..dd861941a 100644
--- a/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
+++ b/test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
@@ -22,7 +22,7 @@ void f3()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unexpected_handler old = std::set_unexpected(f1);
     // verify there is a previous unexpected handler
@@ -33,4 +33,6 @@ int main()
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
diff --git a/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp b/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
index e4d85e1f2..b9bdabe0e 100644
--- a/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
+++ b/test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
@@ -19,9 +19,11 @@ void fexit()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_unexpected(fexit);
     std::unexpected();
     assert(false);
+
+  return 0;
 }
diff --git a/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp b/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
index 6a8549128..0388cfaf7 100644
--- a/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
+++ b/test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
@@ -14,9 +14,11 @@
 
 void f() {}
 
-int main() {
+int main(int, char**) {
   using T = std::unexpected_handler; // expected-error {{no type named 'unexpected_handler' in namespace 'std'}}
   std::unexpected(); // expected-error {{no member named 'unexpected' in namespace 'std'}}
   std::get_unexpected(); // expected-error {{no member named 'get_unexpected' in namespace 'std'}}
   std::set_unexpected(f); // expected-error {{no type named 'set_unexpected' in namespace 'std'}}
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp b/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
index 374ed6fed..f2fb09524 100644
--- a/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
+++ b/test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/enable_nodiscard.fail.cpp b/test/libcxx/diagnostics/enable_nodiscard.fail.cpp
index d756c3f9e..0cd74be2f 100644
--- a/test/libcxx/diagnostics/enable_nodiscard.fail.cpp
+++ b/test/libcxx/diagnostics/enable_nodiscard.fail.cpp
@@ -24,9 +24,11 @@
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
-int main() {
+int main(int, char**) {
   foo(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   bar(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   (void)foo(); // OK. void casts disable the diagnostic.
   (void)bar();
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp b/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
index a7a81f53f..530ea54ca 100644
--- a/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
+++ b/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
@@ -25,8 +25,10 @@
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
-int main() {
+int main(int, char**) {
   foo(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   bar(); // OK.
   (void)foo(); // OK.
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp b/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
index 65b3bbeab..56df9248d 100644
--- a/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
+++ b/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
@@ -23,8 +23,10 @@
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
-int main() {
+int main(int, char**) {
   bar(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   foo(); // OK.
   (void)bar(); // OK.
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp b/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
index c47c75e8c..a8c51c013 100644
--- a/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
+++ b/test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
@@ -15,4 +15,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/diagnostics/nodiscard.pass.cpp b/test/libcxx/diagnostics/nodiscard.pass.cpp
index 628ff57ee..1db9a67a8 100644
--- a/test/libcxx/diagnostics/nodiscard.pass.cpp
+++ b/test/libcxx/diagnostics/nodiscard.pass.cpp
@@ -14,6 +14,8 @@
 
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 
-int main() {
+int main(int, char**) {
   foo(); // OK.
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp b/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
index 250f858be..8cfbc3117 100644
--- a/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
+++ b/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
@@ -16,7 +16,9 @@
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
-int main ()
+int main(int, char**)
 {
 	foo();	// expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp b/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
index 527487faa..959ba4854 100644
--- a/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
+++ b/test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
@@ -16,7 +16,9 @@
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
-int main ()
+int main(int, char**)
 {
 	foo();	// no error here!
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp b/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
index 6fc95bbeb..a265e8755 100644
--- a/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
+++ b/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
@@ -26,9 +26,11 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
     std::get_temporary_buffer<int>(1);
   }
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp b/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
index bd888e5f9..87615fbd0 100644
--- a/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
+++ b/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
@@ -21,8 +21,10 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     std::get_temporary_buffer<int>(1); // intentional memory leak.
   }
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/std.exceptions/version.pass.cpp b/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
index 860c18795..147f4d2b9 100644
--- a/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
+++ b/test/libcxx/diagnostics/std.exceptions/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/diagnostics/syserr/version.pass.cpp b/test/libcxx/diagnostics/syserr/version.pass.cpp
index 6f2dde8ef..4b987a668 100644
--- a/test/libcxx/diagnostics/syserr/version.pass.cpp
+++ b/test/libcxx/diagnostics/syserr/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/double_include.sh.cpp b/test/libcxx/double_include.sh.cpp
index 249b90947..a167b0a58 100644
--- a/test/libcxx/double_include.sh.cpp
+++ b/test/libcxx/double_include.sh.cpp
@@ -168,5 +168,5 @@
 #include <ext/hash_set>
 
 #if defined(WITH_MAIN)
-int main() {}
+int main(int, char**) { return 0; }
 #endif
diff --git a/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp b/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
index ecbf562f8..271e94347 100644
--- a/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
+++ b/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
@@ -14,6 +14,8 @@
 #  error "<experimental/algorithm> must include <algorithm>"
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/algorithms/version.pass.cpp b/test/libcxx/experimental/algorithms/version.pass.cpp
index d0107209f..c43ad68a9 100644
--- a/test/libcxx/experimental/algorithms/version.pass.cpp
+++ b/test/libcxx/experimental/algorithms/version.pass.cpp
@@ -14,6 +14,8 @@
 #  error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp b/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
index 5d72e5e93..a7fef5e73 100644
--- a/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/system_error:* {{"<experimental/system_error> has been removed. Use <system_error> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp b/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
index 7d52c955d..4f6d28c4c 100644
--- a/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
+++ b/test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/filesystem/version.pass.cpp b/test/libcxx/experimental/filesystem/version.pass.cpp
index 09994b6b3..d8b2cbbd1 100644
--- a/test/libcxx/experimental/filesystem/version.pass.cpp
+++ b/test/libcxx/experimental/filesystem/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp b/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
index 5dfdbe840..237fbc4bb 100644
--- a/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
+++ b/test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
@@ -49,10 +49,12 @@ MyFuture test_coro() {
   co_return;
 }
 
-int main()
+int main(int, char**)
 {
   MyFuture f = test_coro();
   while (!f.p.done())
     f.p.resume();
   f.p.destroy();
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp b/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
index a80e3013b..b11ea931f 100644
--- a/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
+++ b/test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
@@ -19,6 +19,8 @@
 #error _LIBCPP_VERSION must be defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
index b92771b4b..e12d31d5f 100644
--- a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -103,7 +103,7 @@ struct CountCopiesAllocV2 {
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         using T = CountCopies;
@@ -167,4 +167,6 @@ int main()
         assert(p.first.alloc == h.M);
         assert(p.second.count == 2);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
index ed583e4e0..38fa265f8 100644
--- a/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
@@ -26,7 +26,7 @@ int AssertCount = 0;
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using Alloc = ex::polymorphic_allocator<int>;
     using Traits = std::allocator_traits<Alloc>;
@@ -38,4 +38,6 @@ int main()
     assert(AssertCount == 0);
     a.deallocate(nullptr, maxSize + 1);
     assert(AssertCount == 1);
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp b/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
index cb4076107..d7a56be43 100644
--- a/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
@@ -26,7 +26,7 @@ int AssertCount = 0;
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using Alloc = NullAllocator<char>;
 
@@ -41,4 +41,6 @@ int main()
     assert(AssertCount == 0);
     m1.deallocate(nullptr, maxSize + 1);
     assert(AssertCount >= 1);
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
index 78586781c..53423a7a7 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
index 35faa8389..8f71d91ab 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
index e29220621..3cdf4794d 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
index f0caac427..94b636f66 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
index 0af172b61..a34c52301 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
index ca5a9faff..70e34c9b0 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
index 99faace64..7969b4f25 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
index ad49a7338..71cfb2c1e 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
index 619bdb446..55a992c71 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
index eb831d6d7..89a8fb0aa 100644
--- a/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp b/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
index a3c0ba1ea..abd737e08 100644
--- a/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
@@ -53,8 +53,10 @@ ex::memory_resource* resource = ex::get_default_resource();
 POSType constructed_after_resources(resource, resource->allocate(1024), 1024);
 POSType constructed_after_resources2(nullptr, resource->allocate(1024), 1024);
 
-int main()
+int main(int, char**)
 {
     swap(constructed_after_resources, constructed_before_resources);
     swap(constructed_before_resources2, constructed_after_resources2);
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp b/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
index c6b4011ce..dc2e9161f 100644
--- a/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
@@ -46,7 +46,9 @@ ex::memory_resource* resource = ex::new_delete_resource();
 
 POSType constructed_after_resources(resource, resource->allocate(1024), 1024);
 
-int main()
+int main(int, char**)
 {
     swap(constructed_after_resources, constructed_before_resources);
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp b/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
index a19049c33..e8d628581 100644
--- a/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
+++ b/test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp b/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
index 656010155..d675acc26 100644
--- a/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/numeric:* {{"<experimental/numeric> has been removed. Use <numeric> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp b/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
index 7295852d3..f8b642d07 100644
--- a/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
+++ b/test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp b/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
index 10a2ebc12..139bc2d1f 100644
--- a/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/string_view:* {{"<experimental/string_view> has been removed. Use <string_view> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/strings/string.view/version.pass.cpp b/test/libcxx/experimental/strings/string.view/version.pass.cpp
index c697d67b1..7300a5501 100644
--- a/test/libcxx/experimental/strings/string.view/version.pass.cpp
+++ b/test/libcxx/experimental/strings/string.view/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
index 69a67ffaf..1b8918e80 100644
--- a/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/any:* {{"<experimental/any> has been removed. Use <any> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/any/version.pass.cpp b/test/libcxx/experimental/utilities/any/version.pass.cpp
index ed8d6f7e8..ecfdecfea 100644
--- a/test/libcxx/experimental/utilities/any/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/any/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/meta/version.pass.cpp b/test/libcxx/experimental/utilities/meta/version.pass.cpp
index 9dd3ca83a..3568c6fe5 100644
--- a/test/libcxx/experimental/utilities/meta/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/meta/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
index 8b23ac69a..d2bb9e6e9 100644
--- a/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/optional:* {{"<experimental/optional> has been removed. Use <optional> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/optional/version.pass.cpp b/test/libcxx/experimental/utilities/optional/version.pass.cpp
index ead45ebf5..0e84f241a 100644
--- a/test/libcxx/experimental/utilities/optional/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/optional/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
index 682872fce..a6578ef48 100644
--- a/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/ratio:* {{"<experimental/ratio> has been removed. Use <ratio> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/ratio/version.pass.cpp b/test/libcxx/experimental/utilities/ratio/version.pass.cpp
index 990b91c71..0357c79ef 100644
--- a/test/libcxx/experimental/utilities/ratio/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/ratio/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
index fc2dc3ad7..093d6fca4 100644
--- a/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/chrono:* {{"<experimental/chrono> has been removed. Use <chrono> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/time/version.pass.cpp b/test/libcxx/experimental/utilities/time/version.pass.cpp
index f14728679..5ff26f7b2 100644
--- a/test/libcxx/experimental/utilities/time/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/time/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp b/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
index 0bc33eca7..6b378c2ce 100644
--- a/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
+++ b/test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/tuple:* {{"<experimental/tuple> has been removed. Use <tuple> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/tuple/version.pass.cpp b/test/libcxx/experimental/utilities/tuple/version.pass.cpp
index 8e4bae634..4c1e305a4 100644
--- a/test/libcxx/experimental/utilities/tuple/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/tuple/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/experimental/utilities/utility/version.pass.cpp b/test/libcxx/experimental/utilities/utility/version.pass.cpp
index 024c56160..5ba32b1ca 100644
--- a/test/libcxx/experimental/utilities/utility/version.pass.cpp
+++ b/test/libcxx/experimental/utilities/utility/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/extensions/hash/specializations.fail.cpp b/test/libcxx/extensions/hash/specializations.fail.cpp
index 19a726bdc..f81ec5dac 100644
--- a/test/libcxx/extensions/hash/specializations.fail.cpp
+++ b/test/libcxx/extensions/hash/specializations.fail.cpp
@@ -10,7 +10,9 @@
 #include <ext/hash_map>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     assert(__gnu_cxx::hash<std::string>()(std::string()) == 0);  // error
+
+  return 0;
 }
diff --git a/test/libcxx/extensions/hash/specializations.pass.cpp b/test/libcxx/extensions/hash/specializations.pass.cpp
index a3f969ba1..9397bbc40 100644
--- a/test/libcxx/extensions/hash/specializations.pass.cpp
+++ b/test/libcxx/extensions/hash/specializations.pass.cpp
@@ -12,7 +12,7 @@
 #include <ext/hash_map>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     char str[] = "test";
     assert(__gnu_cxx::hash<const char *>()("test") ==
@@ -27,4 +27,6 @@ int main()
     assert(__gnu_cxx::hash<unsigned int>()(42) == 42);
     assert(__gnu_cxx::hash<long>()(42) == 42);
     assert(__gnu_cxx::hash<unsigned long>()(42) == 42);
+
+  return 0;
 }
diff --git a/test/libcxx/extensions/hash_map/const_iterator.fail.cpp b/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
index b6389db49..db09e4080 100644
--- a/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
+++ b/test/libcxx/extensions/hash_map/const_iterator.fail.cpp
@@ -8,10 +8,12 @@
 
 #include <ext/hash_map>
 
-int main()
+int main(int, char**)
 {
     __gnu_cxx::hash_map<int, int> m;
     m[1] = 1;
     const __gnu_cxx::hash_map<int, int> &cm = m;
     cm.find(1)->second = 2;  // error
+
+  return 0;
 }
diff --git a/test/libcxx/extensions/nothing_to_do.pass.cpp b/test/libcxx/extensions/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/libcxx/extensions/nothing_to_do.pass.cpp
+++ b/test/libcxx/extensions/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/fuzzing/nth_element.cpp b/test/libcxx/fuzzing/nth_element.cpp
index a7f9e9c22..482aeb65f 100644
--- a/test/libcxx/fuzzing/nth_element.cpp
+++ b/test/libcxx/fuzzing/nth_element.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/partial_sort.cpp b/test/libcxx/fuzzing/partial_sort.cpp
index 2d4d01a09..4f3576663 100644
--- a/test/libcxx/fuzzing/partial_sort.cpp
+++ b/test/libcxx/fuzzing/partial_sort.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/partial_sort_copy.cpp b/test/libcxx/fuzzing/partial_sort_copy.cpp
index 2a7ccbef4..b569f55eb 100644
--- a/test/libcxx/fuzzing/partial_sort_copy.cpp
+++ b/test/libcxx/fuzzing/partial_sort_copy.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/partition.cpp b/test/libcxx/fuzzing/partition.cpp
index c03f17f98..0833e38e2 100644
--- a/test/libcxx/fuzzing/partition.cpp
+++ b/test/libcxx/fuzzing/partition.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/partition_copy.cpp b/test/libcxx/fuzzing/partition_copy.cpp
index f7148bbd0..f336a14ca 100644
--- a/test/libcxx/fuzzing/partition_copy.cpp
+++ b/test/libcxx/fuzzing/partition_copy.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/regex_ECMAScript.cpp b/test/libcxx/fuzzing/regex_ECMAScript.cpp
index 51ca6efa7..ca9a7dae5 100644
--- a/test/libcxx/fuzzing/regex_ECMAScript.cpp
+++ b/test/libcxx/fuzzing/regex_ECMAScript.cpp
@@ -24,7 +24,7 @@ const char * test_cases[] = {
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/regex_POSIX.cpp b/test/libcxx/fuzzing/regex_POSIX.cpp
index 3fcd1bcda..69f40de6d 100644
--- a/test/libcxx/fuzzing/regex_POSIX.cpp
+++ b/test/libcxx/fuzzing/regex_POSIX.cpp
@@ -24,7 +24,7 @@ const char * test_cases[] = {
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/regex_awk.cpp b/test/libcxx/fuzzing/regex_awk.cpp
index 51ca6efa7..ca9a7dae5 100644
--- a/test/libcxx/fuzzing/regex_awk.cpp
+++ b/test/libcxx/fuzzing/regex_awk.cpp
@@ -24,7 +24,7 @@ const char * test_cases[] = {
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/regex_egrep.cpp b/test/libcxx/fuzzing/regex_egrep.cpp
index e44c9e163..f350f63e3 100644
--- a/test/libcxx/fuzzing/regex_egrep.cpp
+++ b/test/libcxx/fuzzing/regex_egrep.cpp
@@ -24,7 +24,7 @@ const char * test_cases[] = {
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/regex_extended.cpp b/test/libcxx/fuzzing/regex_extended.cpp
index dcb7077eb..ae55f5bb8 100644
--- a/test/libcxx/fuzzing/regex_extended.cpp
+++ b/test/libcxx/fuzzing/regex_extended.cpp
@@ -24,7 +24,7 @@ const char * test_cases[] = {
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/regex_grep.cpp b/test/libcxx/fuzzing/regex_grep.cpp
index 50ef9b941..ac497b3a9 100644
--- a/test/libcxx/fuzzing/regex_grep.cpp
+++ b/test/libcxx/fuzzing/regex_grep.cpp
@@ -24,7 +24,7 @@ const char * test_cases[] = {
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/sort.cpp b/test/libcxx/fuzzing/sort.cpp
index 924c4cf88..43b9064de 100644
--- a/test/libcxx/fuzzing/sort.cpp
+++ b/test/libcxx/fuzzing/sort.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/stable_partition.cpp b/test/libcxx/fuzzing/stable_partition.cpp
index af11cb362..b236190cb 100644
--- a/test/libcxx/fuzzing/stable_partition.cpp
+++ b/test/libcxx/fuzzing/stable_partition.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/stable_sort.cpp b/test/libcxx/fuzzing/stable_sort.cpp
index c32be2486..1c8ac4904 100644
--- a/test/libcxx/fuzzing/stable_sort.cpp
+++ b/test/libcxx/fuzzing/stable_sort.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/unique.cpp b/test/libcxx/fuzzing/unique.cpp
index 57317373f..cab512eb8 100644
--- a/test/libcxx/fuzzing/unique.cpp
+++ b/test/libcxx/fuzzing/unique.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/fuzzing/unique_copy.cpp b/test/libcxx/fuzzing/unique_copy.cpp
index c513e60bd..311eb4cf6 100644
--- a/test/libcxx/fuzzing/unique_copy.cpp
+++ b/test/libcxx/fuzzing/unique_copy.cpp
@@ -25,7 +25,7 @@ const char * test_cases[] = {
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
diff --git a/test/libcxx/include_as_c.sh.cpp b/test/libcxx/include_as_c.sh.cpp
index f0dd9bef1..c056f61ae 100644
--- a/test/libcxx/include_as_c.sh.cpp
+++ b/test/libcxx/include_as_c.sh.cpp
@@ -33,4 +33,8 @@
 #include <wchar.h>
 #include <wctype.h>
 
-int main() {}
+int main(int argc, char **argv) {
+  (void)argc;
+  (void)argv;
+  return 0;
+}
diff --git a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
index 04625da88..1c2c329c2 100644
--- a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
@@ -10,7 +10,9 @@
 
 #include <cstdio>
 
-int main() {
+int main(int, char**) {
     // fopen is not available on systems without a global filesystem namespace.
     std::fopen("", "");
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
index 02c9f1fb8..61ef15d17 100644
--- a/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
@@ -10,7 +10,9 @@
 
 #include <cstdio>
 
-int main() {
+int main(int, char**) {
     // rename is not available on systems without a global filesystem namespace.
     std::rename("", "");
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp b/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
index 0325a45e3..d8ff6a7ac 100644
--- a/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp b/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
index 3104bc9aa..23cecf9cb 100644
--- a/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
+++ b/test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp b/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
index d7e80827a..91b678d1d 100644
--- a/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
@@ -15,9 +15,11 @@
 
 #include <fstream>
 
-int main()
+int main(int, char**)
 {
 	std::basic_filebuf<char, std::char_traits<wchar_t> > f;
 //  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
index ff93466da..6af876981 100644
--- a/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
 
@@ -31,4 +31,6 @@ int main()
     assert(!ofs.good());
 
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
index 70621cf79..19442da51 100644
--- a/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -42,4 +42,6 @@ int main()
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
index e7b787592..0dead68c9 100644
--- a/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -48,4 +48,6 @@ int main()
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
index 793b0f6b8..178c7d69a 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     {
@@ -38,4 +38,6 @@ int main()
     // test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
     // which creates writable files.
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
index effbe1e9b..2e8b3620e 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     {
@@ -44,4 +44,6 @@ int main()
         assert(c == L'r');
     }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
index 453caa384..7d6304cc9 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -56,4 +56,6 @@ int main()
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
index 4a847fab3..58f08b865 100644
--- a/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -56,4 +56,6 @@ int main()
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp b/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
index 19dd2ac71..432cfccac 100644
--- a/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
@@ -15,7 +15,7 @@
 
 #include <fstream>
 
-int main()
+int main(int, char**)
 {
 	std::basic_fstream<char, std::char_traits<wchar_t> > f;
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
@@ -25,5 +25,7 @@ int main()
 // exception specifications for types which are already invalid for one reason or another.
 // For now we tolerate this diagnostic.
 // expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
+
+  return 0;
 }
 
diff --git a/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp b/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
index bc578f1b6..515324088 100644
--- a/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
+++ b/test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp b/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
index 0a9fdb54f..396e4ff24 100644
--- a/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
+++ b/test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "filesystem_test_helper.hpp"
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   using ExType = std::__libcpp_debug_exception;
   // Test incrementing/decrementing a singular iterator
@@ -71,4 +71,6 @@ int main() {
       assert(false);
     } catch (ExType const&) {}
   }
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp b/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
index d32b7303a..5eb5cbdb3 100644
--- a/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
+++ b/test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
@@ -16,7 +16,7 @@
 #include <iterator>
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   using RIt = std::reverse_iterator<path::iterator>;
 
@@ -25,4 +25,6 @@ int main() {
     RIt r;
     ((void)r);
   }
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp b/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
index 1cfa173da..a80f02e4c 100644
--- a/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
+++ b/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
@@ -95,9 +95,11 @@ struct MakeTestType {
   }
 };
 
-int main() {
+int main(int, char**) {
   MakeTestType<char>::Test();
   MakeTestType<wchar_t>::Test();
   MakeTestType<char16_t>::Test();
   MakeTestType<char32_t>::Test();
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp b/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
index ac64dc7ab..55cd659cc 100644
--- a/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
+++ b/test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
@@ -277,7 +277,7 @@ struct TestClock {
 template <class IntType, class Period = std::micro>
 using TestFileTimeT = time_point<TestClock<duration<IntType, Period> > >;
 
-int main() {
+int main(int, char**) {
   { assert((test_case<file_time_type, time_t, struct timespec>::test())); }
   {
     assert((test_case<TestFileTimeT<int64_t>, int64_t,
@@ -303,4 +303,6 @@ int main() {
                       TestTimeSpec<int32_t, int32_t> >::test()));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/filesystems/version.pass.cpp b/test/libcxx/input.output/filesystems/version.pass.cpp
index b94e32cbc..b0f031744 100644
--- a/test/libcxx/input.output/filesystems/version.pass.cpp
+++ b/test/libcxx/input.output/filesystems/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp b/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
index 5be4344ab..32088497a 100644
--- a/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
@@ -21,8 +21,10 @@ struct test_istream
     : public std::basic_istream<char, std::char_traits<wchar_t> > {};
 
 
-int main()
+int main(int, char**)
 {
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
diff --git a/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp b/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
index 65c48c11b..77ed7563b 100644
--- a/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp b/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
index caa020f17..897509745 100644
--- a/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
@@ -21,8 +21,10 @@ struct test_ostream
     : public std::basic_ostream<char, std::char_traits<wchar_t> > {};
 
 
-int main()
+int main(int, char**)
 {
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
diff --git a/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp b/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
index f381fcffd..f16e9a079 100644
--- a/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp b/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
index 775eec295..498410ed1 100644
--- a/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/iostream.forward/version.pass.cpp b/test/libcxx/input.output/iostream.forward/version.pass.cpp
index 509d7efdb..70f1ec662 100644
--- a/test/libcxx/input.output/iostream.forward/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.forward/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/iostream.objects/version.pass.cpp b/test/libcxx/input.output/iostream.objects/version.pass.cpp
index f05cdfff7..7081e5abf 100644
--- a/test/libcxx/input.output/iostream.objects/version.pass.cpp
+++ b/test/libcxx/input.output/iostream.objects/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/iostreams.base/version.pass.cpp b/test/libcxx/input.output/iostreams.base/version.pass.cpp
index 8090783e9..4b873a926 100644
--- a/test/libcxx/input.output/iostreams.base/version.pass.cpp
+++ b/test/libcxx/input.output/iostreams.base/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/stream.buffers/version.pass.cpp b/test/libcxx/input.output/stream.buffers/version.pass.cpp
index 08cd62785..cc55444b5 100644
--- a/test/libcxx/input.output/stream.buffers/version.pass.cpp
+++ b/test/libcxx/input.output/stream.buffers/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp b/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
index 0eeb740aa..a046b34ab 100644
--- a/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
+++ b/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
@@ -16,10 +16,12 @@
 
 #include <sstream>
 
-int main()
+int main(int, char**)
 {
 	std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
 //  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
 //  expected-error-re@string:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
diff --git a/test/libcxx/input.output/string.streams/version.pass.cpp b/test/libcxx/input.output/string.streams/version.pass.cpp
index 6725d8509..03beac77b 100644
--- a/test/libcxx/input.output/string.streams/version.pass.cpp
+++ b/test/libcxx/input.output/string.streams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/iterators/failed.pass.cpp b/test/libcxx/iterators/failed.pass.cpp
index b9bcb0250..e44c15eba 100644
--- a/test/libcxx/iterators/failed.pass.cpp
+++ b/test/libcxx/iterators/failed.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostreambuf_iterator<char> i(nullptr);
@@ -28,4 +28,6 @@ int main()
         std::ostreambuf_iterator<wchar_t> i(nullptr);
         assert(i.failed());
     }
+
+  return 0;
 }
diff --git a/test/libcxx/iterators/trivial_iterators.pass.cpp b/test/libcxx/iterators/trivial_iterators.pass.cpp
index 0a77befed..0618731ce 100644
--- a/test/libcxx/iterators/trivial_iterators.pass.cpp
+++ b/test/libcxx/iterators/trivial_iterators.pass.cpp
@@ -90,7 +90,7 @@ operator!=(const my_input_iterator<T>& x, const my_input_iterator<U>& y)
 }
 
 
-int main()
+int main(int, char**)
 {
 //  basic tests
     static_assert(( std::__libcpp_is_trivial_iterator<char *>::value), "");
@@ -184,4 +184,6 @@ int main()
     static_assert(( std::__libcpp_is_trivial_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
 #endif
 
+
+  return 0;
 }
diff --git a/test/libcxx/iterators/version.pass.cpp b/test/libcxx/iterators/version.pass.cpp
index 9fe0a9e2e..16668898a 100644
--- a/test/libcxx/iterators/version.pass.cpp
+++ b/test/libcxx/iterators/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/cmp/version.pass.cpp b/test/libcxx/language.support/cmp/version.pass.cpp
index ae3a573d7..9d2ae8ac1 100644
--- a/test/libcxx/language.support/cmp/version.pass.cpp
+++ b/test/libcxx/language.support/cmp/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/cstdint/version.pass.cpp b/test/libcxx/language.support/cstdint/version.pass.cpp
index 31822ac7a..9f11f15d1 100644
--- a/test/libcxx/language.support/cstdint/version.pass.cpp
+++ b/test/libcxx/language.support/cstdint/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
index 043981970..b5171a39e 100644
--- a/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
+++ b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
@@ -21,7 +21,9 @@
 // XFAIL: with_system_cxx_lib=macosx10.7
 
 struct S { virtual void f() = delete; virtual ~S() {} };
-int main() {
+int main(int, char**) {
   S *s = new S;
   delete s;
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/has_c11_features.pass.cpp b/test/libcxx/language.support/has_c11_features.pass.cpp
index 1bba504cd..7abdbc1c8 100644
--- a/test/libcxx/language.support/has_c11_features.pass.cpp
+++ b/test/libcxx/language.support/has_c11_features.pass.cpp
@@ -28,4 +28,6 @@
 # endif
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
index be2e69e68..04ba34ca0 100644
--- a/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
+++ b/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
@@ -253,7 +253,9 @@ void test_allocator_and_new_match() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_libcpp_dealloc();
   test_allocator_and_new_match();
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp b/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
index 65943139f..f3db56478 100644
--- a/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
+++ b/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
@@ -36,7 +36,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     static_assert(std::is_enum<std::align_val_t>::value, "");
     typedef std::underlying_type<std::align_val_t>::type UT;
@@ -88,4 +88,6 @@ int main() {
     assert(typeid(std::align_val_t).name() == std::string("St11align_val_t"));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.dynamic/version.pass.cpp b/test/libcxx/language.support/support.dynamic/version.pass.cpp
index a3ca4f617..c3f542ca8 100644
--- a/test/libcxx/language.support/support.dynamic/version.pass.cpp
+++ b/test/libcxx/language.support/support.dynamic/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.exception/version.pass.cpp b/test/libcxx/language.support/support.exception/version.pass.cpp
index 1161e67d0..495a8cde9 100644
--- a/test/libcxx/language.support/support.exception/version.pass.cpp
+++ b/test/libcxx/language.support/support.exception/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.initlist/version.pass.cpp b/test/libcxx/language.support/support.initlist/version.pass.cpp
index 9b11ce1c6..6f42987b1 100644
--- a/test/libcxx/language.support/support.initlist/version.pass.cpp
+++ b/test/libcxx/language.support/support.initlist/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp b/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
index ee03d9ef0..baa925f7d 100644
--- a/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
+++ b/test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp b/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
index 94fd729c4..208b16ed7 100644
--- a/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
+++ b/test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.limits/limits/version.pass.cpp b/test/libcxx/language.support/support.limits/limits/version.pass.cpp
index 4d9ba3892..a17643bc4 100644
--- a/test/libcxx/language.support/support.limits/limits/version.pass.cpp
+++ b/test/libcxx/language.support/support.limits/limits/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.limits/version.pass.cpp b/test/libcxx/language.support/support.limits/version.pass.cpp
index e884d285a..4277147f6 100644
--- a/test/libcxx/language.support/support.limits/version.pass.cpp
+++ b/test/libcxx/language.support/support.limits/version.pass.cpp
@@ -14,6 +14,8 @@
 #error "_LIBCPP_VERSION must be defined after including <version>"
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.rtti/version.pass.cpp b/test/libcxx/language.support/support.rtti/version.pass.cpp
index 84d74db3d..3d21c8487 100644
--- a/test/libcxx/language.support/support.rtti/version.pass.cpp
+++ b/test/libcxx/language.support/support.rtti/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp b/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
index 261dd3cde..9bceaf823 100644
--- a/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp b/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
index a602675ce..b93fb0d17 100644
--- a/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
index 1dde2b656..0ddd98b52 100644
--- a/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
index 219efa153..85f1fb34d 100644
--- a/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp b/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
index 431e3d9a9..9a5a02fb8 100644
--- a/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp b/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
index d38788602..bc2d039b3 100644
--- a/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
+++ b/test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/language.support/support.types/version.pass.cpp b/test/libcxx/language.support/support.types/version.pass.cpp
index 8c05c6563..5dd755c00 100644
--- a/test/libcxx/language.support/support.types/version.pass.cpp
+++ b/test/libcxx/language.support/support.types/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/libcpp_alignof.pass.cpp b/test/libcxx/libcpp_alignof.pass.cpp
index ab64889b5..0f6721084 100644
--- a/test/libcxx/libcpp_alignof.pass.cpp
+++ b/test/libcxx/libcpp_alignof.pass.cpp
@@ -28,9 +28,10 @@ void test() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test<int>();
   test<long long>();
   test<double>();
   test<long double>();
+  return 0;
 }
diff --git a/test/libcxx/libcpp_version.pass.cpp b/test/libcxx/libcpp_version.pass.cpp
index 9d7e6dce1..a2d18c3bb 100644
--- a/test/libcxx/libcpp_version.pass.cpp
+++ b/test/libcxx/libcpp_version.pass.cpp
@@ -22,6 +22,8 @@ static const int libcpp_version =
 static_assert(_LIBCPP_VERSION == libcpp_version,
               "_LIBCPP_VERSION doesn't match __libcpp_version");
 
-int main() {
+int main(int, char**) {
 
+
+  return 0;
 }
diff --git a/test/libcxx/localization/c.locales/version.pass.cpp b/test/libcxx/localization/c.locales/version.pass.cpp
index 5a4f1064c..2dfc76dd9 100644
--- a/test/libcxx/localization/c.locales/version.pass.cpp
+++ b/test/libcxx/localization/c.locales/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp b/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
index 6da1aa575..b85bd8a58 100644
--- a/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
+++ b/test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
@@ -38,7 +38,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::ctype<char>& ct = std::use_facet<std::ctype<char> >(std::locale::classic());
     std::ios_base::iostate err = std::ios_base::goodbit;
@@ -114,4 +114,6 @@ int main()
         assert(in == input+3);
         assert(err == std::ios_base::goodbit);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/localization/locale.stdcvt/version.pass.cpp b/test/libcxx/localization/locale.stdcvt/version.pass.cpp
index 1e346afb6..738ab5e41 100644
--- a/test/libcxx/localization/locale.stdcvt/version.pass.cpp
+++ b/test/libcxx/localization/locale.stdcvt/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp b/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
index 996f6bdc6..3aac6f532 100644
--- a/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
+++ b/test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
@@ -34,4 +34,6 @@ int main()
     // move construct a new converter and make sure the state is the same.
     Myconv myconv2(std::move(myconv));
     assert(myconv2.converted() == old_converted);
+
+  return 0;
 }
diff --git a/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp b/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
index 668cb55c6..7be14d6be 100644
--- a/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
+++ b/test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
@@ -35,7 +35,7 @@ struct my_facet
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     my_facet* f = new my_facet;
     f->__add_shared();
@@ -49,4 +49,6 @@ int main()
     assert(my_facet::count == 1);
     f->__release_shared();
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp b/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
index 6844a0ad0..758d7f8b8 100644
--- a/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
+++ b/test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
@@ -25,7 +25,7 @@ std::locale::id id0;
 std::locale::id id2;
 std::locale::id id1;
 
-int main()
+int main(int, char**)
 {
     long id = id0.__get();
     assert(id0.__get() == id+0);
@@ -46,4 +46,6 @@ int main()
     assert(id2.__get() == id+2);
     assert(id2.__get() == id+2);
     assert(id2.__get() == id+2);
+
+  return 0;
 }
diff --git a/test/libcxx/localization/version.pass.cpp b/test/libcxx/localization/version.pass.cpp
index 8b73ba589..1d1294593 100644
--- a/test/libcxx/localization/version.pass.cpp
+++ b/test/libcxx/localization/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/memory/aligned_allocation_macro.pass.cpp b/test/libcxx/memory/aligned_allocation_macro.pass.cpp
index b4aad040c..7099eed2e 100644
--- a/test/libcxx/memory/aligned_allocation_macro.pass.cpp
+++ b/test/libcxx/memory/aligned_allocation_macro.pass.cpp
@@ -27,4 +27,6 @@
 #   error "libc++ should have aligned allocation in C++17 and up when targeting a platform that supports it"
 #endif
 
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
diff --git a/test/libcxx/memory/is_allocator.pass.cpp b/test/libcxx/memory/is_allocator.pass.cpp
index d0f3e9c27..d62a91f7d 100644
--- a/test/libcxx/memory/is_allocator.pass.cpp
+++ b/test/libcxx/memory/is_allocator.pass.cpp
@@ -32,10 +32,12 @@ void test_allocators()
 }
 
 
-int main()
+int main(int, char**)
 {
 //	test_allocators<void>();
 	test_allocators<char>();
 	test_allocators<int>();
 	test_allocators<std::string>();
+
+  return 0;
 }
diff --git a/test/libcxx/modules/cinttypes_exports.sh.cpp b/test/libcxx/modules/cinttypes_exports.sh.cpp
index 6e6c515e1..a24aafdcc 100644
--- a/test/libcxx/modules/cinttypes_exports.sh.cpp
+++ b/test/libcxx/modules/cinttypes_exports.sh.cpp
@@ -18,7 +18,9 @@
 
 #include <cinttypes>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
   std::int8_t y; ((void)y);
+
+  return 0;
 }
diff --git a/test/libcxx/modules/clocale_exports.sh.cpp b/test/libcxx/modules/clocale_exports.sh.cpp
index 480308c1e..3225155ca 100644
--- a/test/libcxx/modules/clocale_exports.sh.cpp
+++ b/test/libcxx/modules/clocale_exports.sh.cpp
@@ -19,9 +19,11 @@
 
 #define TEST(...) do { using T = decltype( __VA_ARGS__ ); } while(false)
 
-int main() {
+int main(int, char**) {
   std::lconv l; ((void)l);
 
   TEST(std::setlocale(0, ""));
   TEST(std::localeconv());
+
+  return 0;
 }
diff --git a/test/libcxx/modules/cstdint_exports.sh.cpp b/test/libcxx/modules/cstdint_exports.sh.cpp
index 8ecb15c5c..315d9ac17 100644
--- a/test/libcxx/modules/cstdint_exports.sh.cpp
+++ b/test/libcxx/modules/cstdint_exports.sh.cpp
@@ -18,7 +18,9 @@
 
 #include <cstdint>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
   std::int8_t y; ((void)y);
+
+  return 0;
 }
diff --git a/test/libcxx/modules/inttypes_h_exports.sh.cpp b/test/libcxx/modules/inttypes_h_exports.sh.cpp
index a51608c67..4cbb1d574 100644
--- a/test/libcxx/modules/inttypes_h_exports.sh.cpp
+++ b/test/libcxx/modules/inttypes_h_exports.sh.cpp
@@ -18,6 +18,8 @@
 
 #include <inttypes.h>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
+
+  return 0;
 }
diff --git a/test/libcxx/modules/stdint_h_exports.sh.cpp b/test/libcxx/modules/stdint_h_exports.sh.cpp
index 584a46515..5b35ba30c 100644
--- a/test/libcxx/modules/stdint_h_exports.sh.cpp
+++ b/test/libcxx/modules/stdint_h_exports.sh.cpp
@@ -14,6 +14,8 @@
 
 #include <stdint.h>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
index b15467cfd..330b3a134 100644
--- a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
+++ b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
@@ -26,6 +26,8 @@ static_assert(std::__libcpp_isnan_or_builtin(0.) == false, "");
 static_assert(std::__libcpp_isinf_or_builtin(0.0) == false, "");
 static_assert(std::__libcpp_isfinite_or_builtin(0.0) == true, "");
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/c.math/ctgmath.pass.cpp b/test/libcxx/numerics/c.math/ctgmath.pass.cpp
index 3b7015795..81eac056b 100644
--- a/test/libcxx/numerics/c.math/ctgmath.pass.cpp
+++ b/test/libcxx/numerics/c.math/ctgmath.pass.cpp
@@ -14,10 +14,12 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     ((void)cd);
     double x = std::sin(0);
     ((void)x);
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
index 6007268b2..37d09a879 100644
--- a/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
+++ b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
@@ -18,10 +18,12 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   assert(std::isfinite(1.0));
   assert(!std::isinf(1.0));
   assert(!std::isnan(1.0));
+
+  return 0;
 }
 
 using namespace std;
diff --git a/test/libcxx/numerics/c.math/tgmath_h.pass.cpp b/test/libcxx/numerics/c.math/tgmath_h.pass.cpp
index 3c2388992..d3cd15ca0 100644
--- a/test/libcxx/numerics/c.math/tgmath_h.pass.cpp
+++ b/test/libcxx/numerics/c.math/tgmath_h.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/c.math/version_cmath.pass.cpp b/test/libcxx/numerics/c.math/version_cmath.pass.cpp
index b11a6a2e8..1b4ab9a6d 100644
--- a/test/libcxx/numerics/c.math/version_cmath.pass.cpp
+++ b/test/libcxx/numerics/c.math/version_cmath.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/cfenv/version.pass.cpp b/test/libcxx/numerics/cfenv/version.pass.cpp
index 8b523916a..9ce5b9c4c 100644
--- a/test/libcxx/numerics/cfenv/version.pass.cpp
+++ b/test/libcxx/numerics/cfenv/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/complex.number/__sqr.pass.cpp b/test/libcxx/numerics/complex.number/__sqr.pass.cpp
index 4ef3d773b..3a6aec0ac 100644
--- a/test/libcxx/numerics/complex.number/__sqr.pass.cpp
+++ b/test/libcxx/numerics/complex.number/__sqr.pass.cpp
@@ -72,9 +72,11 @@ test()
     assert(inf2.real() < 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index 4fe737ed9..ff03bd09f 100644
--- a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -14,8 +14,10 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/complex.number/version.pass.cpp b/test/libcxx/numerics/complex.number/version.pass.cpp
index c7dfb72dc..ec3996e54 100644
--- a/test/libcxx/numerics/complex.number/version.pass.cpp
+++ b/test/libcxx/numerics/complex.number/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/numarray/version.pass.cpp b/test/libcxx/numerics/numarray/version.pass.cpp
index ffe443d09..b921ae247 100644
--- a/test/libcxx/numerics/numarray/version.pass.cpp
+++ b/test/libcxx/numerics/numarray/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/numeric.ops/version.pass.cpp b/test/libcxx/numerics/numeric.ops/version.pass.cpp
index 2ae08be3e..50a07a639 100644
--- a/test/libcxx/numerics/numeric.ops/version.pass.cpp
+++ b/test/libcxx/numerics/numeric.ops/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp b/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
index faddb6592..b9f876d0f 100644
--- a/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
+++ b/test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/selftest/not_test.sh.cpp b/test/libcxx/selftest/not_test.sh.cpp
index 4e0196752..8dbf708f0 100644
--- a/test/libcxx/selftest/not_test.sh.cpp
+++ b/test/libcxx/selftest/not_test.sh.cpp
@@ -10,7 +10,7 @@
 // RUN: %build
 // RUN: not %run
 
-int main()
+int main(int, char**)
 {
   return 1;
 }
diff --git a/test/libcxx/selftest/test.arc.pass.mm b/test/libcxx/selftest/test.arc.pass.mm
index df4e83264..eecdbb616 100644
--- a/test/libcxx/selftest/test.arc.pass.mm
+++ b/test/libcxx/selftest/test.arc.pass.mm
@@ -11,6 +11,4 @@
 #error "arc should be enabled"
 #endif
 
-int main()
-{
-}
+int main(int, char**) { return 0; }
diff --git a/test/libcxx/selftest/test.pass.cpp b/test/libcxx/selftest/test.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/libcxx/selftest/test.pass.cpp
+++ b/test/libcxx/selftest/test.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/selftest/test.pass.mm b/test/libcxx/selftest/test.pass.mm
index e5e5f5c41..ba4d36bbe 100644
--- a/test/libcxx/selftest/test.pass.mm
+++ b/test/libcxx/selftest/test.pass.mm
@@ -11,6 +11,4 @@
 #error "arc should *not* be enabled"
 #endif
 
-int main()
-{
-}
+int main(int, char**) { return 0; }
diff --git a/test/libcxx/selftest/test.sh.cpp b/test/libcxx/selftest/test.sh.cpp
index b7e5e9d80..1fc175413 100644
--- a/test/libcxx/selftest/test.sh.cpp
+++ b/test/libcxx/selftest/test.sh.cpp
@@ -10,6 +10,8 @@
 // RUN: %build
 // RUN: %run
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/selftest/test_macros.pass.cpp b/test/libcxx/selftest/test_macros.pass.cpp
index 63659e594..d7baeb2f9 100644
--- a/test/libcxx/selftest/test_macros.pass.cpp
+++ b/test/libcxx/selftest/test_macros.pass.cpp
@@ -58,8 +58,10 @@ void test_libcxx_macros()
 //  ===== C++17 features =====
 }
 
-int main()
+int main(int, char**)
 {
     test_noexcept();
     test_libcxx_macros();
+
+  return 0;
 }
diff --git a/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
index 4275bad39..b0de5d879 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string l = "Long string so that allocation definitely, for sure, absolutely happens. Probably.";
     std::string s = "short";
@@ -40,8 +40,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
index e397e0c85..a5258f95d 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
index db11f17a1..099ce74f7 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -45,8 +45,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
index 736677b5e..1802f6287 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
index 6f10d3f7e..fe65851ef 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
index f6f23f111..fad146451 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
index 0446df020..3186ad449 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -41,8 +41,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
index 4276dfcdb..2516a69f5 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -28,4 +28,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
index 39b1fde16..7925e1597 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -30,4 +30,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
index fb3771d91..81f888f86 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -27,4 +27,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp b/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
index ca9fb0512..3fab03c01 100644
--- a/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
+++ b/test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
@@ -56,7 +56,9 @@ void test_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_buffer_usage();
+
+  return 0;
 }
diff --git a/test/libcxx/strings/c.strings/version_cctype.pass.cpp b/test/libcxx/strings/c.strings/version_cctype.pass.cpp
index 9a0b4a6f0..47e857679 100644
--- a/test/libcxx/strings/c.strings/version_cctype.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cctype.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/strings/c.strings/version_cstring.pass.cpp b/test/libcxx/strings/c.strings/version_cstring.pass.cpp
index a986f294e..21388b410 100644
--- a/test/libcxx/strings/c.strings/version_cstring.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cstring.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/strings/c.strings/version_cuchar.pass.cpp b/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
index 40fa8ef23..8c6a9de70 100644
--- a/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cuchar.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/strings/c.strings/version_cwchar.pass.cpp b/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
index 424c85fc2..f7539d4e8 100644
--- a/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cwchar.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/strings/c.strings/version_cwctype.pass.cpp b/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
index 62320f8f5..06aacb1fe 100644
--- a/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
+++ b/test/libcxx/strings/c.strings/version_cwctype.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/strings/iterators.exceptions.pass.cpp b/test/libcxx/strings/iterators.exceptions.pass.cpp
index 07787edff..471e6bea5 100644
--- a/test/libcxx/strings/iterators.exceptions.pass.cpp
+++ b/test/libcxx/strings/iterators.exceptions.pass.cpp
@@ -33,7 +33,7 @@ static const bool expected = false;
 static const bool expected = true;
 #endif
 
-int main()
+int main(int, char**)
 {
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
@@ -84,4 +84,6 @@ int main()
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/strings/iterators.noexcept.pass.cpp b/test/libcxx/strings/iterators.noexcept.pass.cpp
index 01c15e3c9..b46bc639b 100644
--- a/test/libcxx/strings/iterators.noexcept.pass.cpp
+++ b/test/libcxx/strings/iterators.noexcept.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
@@ -77,4 +77,6 @@ int main()
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/strings/version.pass.cpp b/test/libcxx/strings/version.pass.cpp
index e378fce09..f106780e3 100644
--- a/test/libcxx/strings/version.pass.cpp
+++ b/test/libcxx/strings/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp b/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
index 6109081d1..78a8aaaa5 100644
--- a/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
+++ b/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
@@ -31,7 +31,7 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     typedef std::__libcpp_debug_exception ExType;
     {
@@ -52,4 +52,6 @@ int main()
         } catch (ExType const&) {
         }
     }
+
+  return 0;
 }
diff --git a/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp b/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
index 35fde08bd..baf5ba9bf 100644
--- a/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
+++ b/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -31,7 +31,7 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     typedef std::__libcpp_debug_exception ExType;
     {
@@ -52,4 +52,6 @@ int main()
         } catch (ExType const& value) {
         }
     }
+
+  return 0;
 }
diff --git a/test/libcxx/thread/futures/futures.task/types.pass.cpp b/test/libcxx/thread/futures/futures.task/types.pass.cpp
index 22aae509e..75bf29503 100644
--- a/test/libcxx/thread/futures/futures.task/types.pass.cpp
+++ b/test/libcxx/thread/futures/futures.task/types.pass.cpp
@@ -24,7 +24,9 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::packaged_task<A(int, char)>::result_type, A>::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/thread/futures/version.pass.cpp b/test/libcxx/thread/futures/version.pass.cpp
index ceb0a5561..fd2c30433 100644
--- a/test/libcxx/thread/futures/version.pass.cpp
+++ b/test/libcxx/thread/futures/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
index 811883554..2ad5c6256 100644
--- a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
+++ b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
@@ -45,7 +45,7 @@ void* func(void*)
     return nullptr;
 }
 
-int main()
+int main(int, char**)
 {
     {
     std::unique_lock<std::mutex> lk(mut);
@@ -72,4 +72,6 @@ int main()
     assert(t1-t0 > ms(250));
     t.join();
     }
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp b/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
index f9facefff..4b983ff05 100644
--- a/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
@@ -20,11 +20,13 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::condition_variable::native_handle_type,
                                 pthread_cond_t*>::value), "");
     std::condition_variable cv;
     std::condition_variable::native_handle_type h = cv.native_handle();
     assert(h != nullptr);
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.condition/version.pass.cpp b/test/libcxx/thread/thread.condition/version.pass.cpp
index b3cfd4a3d..2354b3b9f 100644
--- a/test/libcxx/thread/thread.condition/version.pass.cpp
+++ b/test/libcxx/thread/thread.condition/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
index 28137444a..b85efcb64 100644
--- a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
@@ -20,9 +20,11 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::mutex m;
     pthread_mutex_t* h = m.native_handle();
     assert(h);
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
index 2a0eab4f4..4a6c53995 100644
--- a/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
@@ -20,9 +20,11 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m;
     pthread_mutex_t* h = m.native_handle();
     assert(h);
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
index 37f912bd9..65a1d6e12 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
@@ -16,10 +16,12 @@
 
 #include <mutex>
 
-int main() {
+int main(int, char**) {
   std::mutex m;
   m.lock();
   {
     std::unique_lock<std::mutex> g(m, std::adopt_lock);
   }
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
index 58545f8ce..8f8b6ce1c 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
@@ -32,8 +32,10 @@ static void scoped() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   scoped();
   std::lock_guard<std::mutex> lock(m);
   foo++;
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
index 5211c5e63..e29801228 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
@@ -23,8 +23,10 @@
 std::mutex m;
 int foo __attribute__((guarded_by(m)));
 
-int main() {
+int main(int, char**) {
   m.lock();
   foo++;
   m.unlock();
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp b/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
index 9479566a9..7dd3f5da2 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
@@ -22,6 +22,8 @@
 
 std::mutex m;
 
-int main() {
+int main(int, char**) {
   m.lock();
+
+  return 0;
 } // expected-error {{mutex 'm' is still held at the end of function}}
diff --git a/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp b/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
index 772db283a..2e427f217 100644
--- a/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
@@ -27,8 +27,10 @@ void increment() __attribute__((requires_capability(m))) {
   foo++;
 }
 
-int main() {
+int main(int, char**) {
   m.lock();
   increment();
   m.unlock();
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.mutex/version.pass.cpp b/test/libcxx/thread/thread.mutex/version.pass.cpp
index c996c1c7a..abe4fda96 100644
--- a/test/libcxx/thread/thread.mutex/version.pass.cpp
+++ b/test/libcxx/thread/thread.mutex/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
index fa69bec03..1bf7e521d 100644
--- a/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
@@ -43,7 +43,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -52,4 +52,6 @@ int main()
         assert(pid != 0);
         t0.join();
     }
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
index 9d021fe16..4f6bd1206 100644
--- a/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
@@ -21,7 +21,9 @@
 #include <thread>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::thread::native_handle_type, pthread_t>::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp b/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
index 248284ea5..f11f40611 100644
--- a/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
+++ b/test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
@@ -34,7 +34,7 @@
 
 void sig_action(int) {}
 
-int main()
+int main(int, char**)
 {
     int ec;
     struct sigaction action;
@@ -64,4 +64,6 @@ int main()
     std::chrono::nanoseconds err = 5 * ms / 100;
     // The time slept is within 5% of 500ms
     assert(std::abs(ns.count()) < err.count());
+
+  return 0;
 }
diff --git a/test/libcxx/thread/thread.threads/version.pass.cpp b/test/libcxx/thread/thread.threads/version.pass.cpp
index 07e6c933f..3d7866228 100644
--- a/test/libcxx/thread/thread.threads/version.pass.cpp
+++ b/test/libcxx/thread/thread.threads/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/type_traits/convert_to_integral.pass.cpp b/test/libcxx/type_traits/convert_to_integral.pass.cpp
index 155f985d1..08b6b5e8b 100644
--- a/test/libcxx/type_traits/convert_to_integral.pass.cpp
+++ b/test/libcxx/type_traits/convert_to_integral.pass.cpp
@@ -79,7 +79,7 @@ enum enum2 : unsigned long {
   value = std::numeric_limits<unsigned long>::max()
 };
 
-int main()
+int main(int, char**)
 {
   check_integral_types<bool, int>();
   check_integral_types<char, int>();
@@ -105,4 +105,6 @@ int main()
   check_enum_types<enum1, decltype(((Enum1UT)1) + 1)>();
   typedef std::underlying_type<enum2>::type Enum2UT;
   check_enum_types<enum2, decltype(((Enum2UT)1) + 1)>();
+
+  return 0;
 }
diff --git a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
index 84e80afe4..2ea1d6891 100644
--- a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
+++ b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
@@ -128,9 +128,11 @@ void LazyOrTest() {
 }
 
 
-int main() {
+int main(int, char**) {
     LazyEnableIfTest();
     LazyNotTest();
     LazyAndTest();
     LazyOrTest();
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/any/size_and_alignment.pass.cpp b/test/libcxx/utilities/any/size_and_alignment.pass.cpp
index 99ff53273..4e3646660 100644
--- a/test/libcxx/utilities/any/size_and_alignment.pass.cpp
+++ b/test/libcxx/utilities/any/size_and_alignment.pass.cpp
@@ -14,9 +14,11 @@
 
 #include <any>
 
-int main()
+int main(int, char**)
 {
     using std::any;
     static_assert(sizeof(any) == sizeof(void*)*4, "");
     static_assert(alignof(any) == alignof(void*), "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/any/small_type.pass.cpp b/test/libcxx/utilities/any/small_type.pass.cpp
index f4cd46fdb..9df6efc14 100644
--- a/test/libcxx/utilities/any/small_type.pass.cpp
+++ b/test/libcxx/utilities/any/small_type.pass.cpp
@@ -54,7 +54,7 @@ struct alignas(DoubleBufferAlignment) OverSizeAndAlignedType {
     char buff[BufferSize + 1];
 };
 
-int main()
+int main(int, char**)
 {
     using std::any;
     using std::__any_imp::_IsSmallObject;
@@ -110,4 +110,6 @@ int main()
         static_assert(alignof(T) > BufferAlignment, "");
         static_assert(!_IsSmallObject<T>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/any/version.pass.cpp b/test/libcxx/utilities/any/version.pass.cpp
index 75e4544ef..ee5bc9928 100644
--- a/test/libcxx/utilities/any/version.pass.cpp
+++ b/test/libcxx/utilities/any/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
index b2946ab81..28ee3a39a 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
@@ -271,7 +271,7 @@ void test_derived_from_ref_wrap() {
 }
 #endif
 
-int main() {
+int main(int, char**) {
     typedef void*& R;
     typedef ArgType A;
     TestCase<R(),                                   0, Q_None>::run();
@@ -367,4 +367,6 @@ int main() {
 
     test_derived_from_ref_wrap();
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
index 15ab7adb4..ff7549d29 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
@@ -206,10 +206,12 @@ private:
 
 
 
-int main() {
+int main(int, char**) {
     TestCase<ArgType>::run();
     TestCase<ArgType const>::run();
     TestCase<ArgType volatile>::run();
     TestCase<ArgType const volatile>::run();
     TestCase<ArgType*>::run();
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
index 469452706..fb789fa0a 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
@@ -247,7 +247,7 @@ void runTestCase() {
     runFunctorTestCase <Sig, Arity, LValueCaster, ArgCaster>();
 };
 
-int main() {
+int main(int, char**) {
     typedef void*& R;
     typedef ArgType A;
     typedef A const CA;
@@ -323,4 +323,6 @@ int main() {
     runFunctorTestCase11<R(A&&) const volatile &&, 1, MoveCVCaster,       MC>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp b/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
index acc0c778f..e534553a8 100644
--- a/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
@@ -31,7 +31,7 @@ struct Type
 #endif
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::__invoke(&Type::f1, std::declval<Type        >())) == 1, "");
     static_assert(sizeof(std::__invoke(&Type::f2, std::declval<Type const  >())) == 2, "");
@@ -41,4 +41,6 @@ int main()
     static_assert(sizeof(std::__invoke(&Type::g3, std::declval<Type      &&>())) == 3, "");
     static_assert(sizeof(std::__invoke(&Type::g4, std::declval<Type const&&>())) == 4, "");
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp b/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
index de0b9508a..1f5bbcdef 100644
--- a/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
+++ b/test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
@@ -46,7 +46,7 @@ struct C
     typedef int result_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((!std::is_base_of<std::binary_function<int, char, int>,
                                     std::reference_wrapper<functor1> >::value), "");
@@ -76,4 +76,6 @@ int main()
                                    std::reference_wrapper<float(C::*)(int)> >::value), "");
     static_assert((std::is_base_of<std::binary_function<const volatile C*, int, float>,
                                    std::reference_wrapper<float(C::*)(int) const volatile> >::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp b/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
index 27e2763db..429722e47 100644
--- a/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
+++ b/test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
@@ -46,7 +46,7 @@ struct C
     typedef int result_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::unary_function<int, char>,
                                    std::reference_wrapper<functor1> >::value), "");
@@ -74,4 +74,6 @@ int main()
                                    std::reference_wrapper<float(C::*)() const volatile> >::value), "");
     static_assert((!std::is_base_of<std::unary_function<C*, float>,
                                    std::reference_wrapper<float(C::*)(int)> >::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp b/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
index 7241bc059..54f4db764 100644
--- a/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
+++ b/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
@@ -28,7 +28,7 @@ void test(const void* key, int len) {
   }
 }
 
-int main() {
+int main(int, char**) {
   const std::string TestCases[] = {
       "abcdaoeuaoeclaoeoaeuaoeuaousaotehu]+}sthoasuthaoesutahoesutaohesutaoeusaoetuhasoetuhaoseutaoseuthaoesutaohes"
       "00000000000000000000000000000000000000000000000000000000000000000000000",
@@ -37,4 +37,6 @@ int main() {
   const size_t NumCases = sizeof(TestCases)/sizeof(TestCases[0]);
   for (size_t i=0; i < NumCases; ++i)
     test(TestCases[i].data(), TestCases[i].length());
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/function.objects/version.pass.cpp b/test/libcxx/utilities/function.objects/version.pass.cpp
index 41bbca6f6..6f8540f1a 100644
--- a/test/libcxx/utilities/function.objects/version.pass.cpp
+++ b/test/libcxx/utilities/function.objects/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
index d0410c51b..deab4368a 100644
--- a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
+++ b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
@@ -28,7 +28,7 @@ void test_pr26961() {
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_IS_UNSUPPORTED
   {
@@ -42,4 +42,6 @@ int main()
     test_pr26961();
   }
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
index 2ff19d45e..c8e0c7292 100644
--- a/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
+++ b/test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
@@ -18,7 +18,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
   {
     static_assert(std::is_enum<std::pointer_safety>::value, "");
@@ -34,4 +34,6 @@ int main()
            r == std::pointer_safety::preferred ||
            r == std::pointer_safety::strict);
   }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp b/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
index e3091aa5a..bf12e1459 100644
--- a/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
+++ b/test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
@@ -77,7 +77,7 @@ void run_test(Ptr p) {
     assert(p.use_count() == 3);
 }
 
-int main() {
+int main(int, char**) {
   {
     // Test with out-of-place shared_count.
     Ptr p(new int(42));
@@ -91,4 +91,6 @@ int main() {
     run_test(p);
     assert(p.use_count() == 1);
   }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp b/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
index c94ce75fe..e9b4257a7 100644
--- a/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
+++ b/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
@@ -29,7 +29,7 @@ struct Deleter {
   }
 };
 
-int main() {
+int main(int, char**) {
   {
     SPtr<0> s; // OK
     SPtr<1> s1(nullptr); // OK
@@ -41,4 +41,6 @@ int main() {
     SPtr<4> s4(getFn<4>()); // expected-note {{requested here}}
     SPtr<5> s5(getFn<5>(), std::default_delete<FnType<5>>{}); // expected-note {{requested here}}
   }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/memory/version.pass.cpp b/test/libcxx/utilities/memory/version.pass.cpp
index e5359a5d4..5b10e1425 100644
--- a/test/libcxx/utilities/memory/version.pass.cpp
+++ b/test/libcxx/utilities/memory/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/meta/is_referenceable.pass.cpp b/test/libcxx/utilities/meta/is_referenceable.pass.cpp
index 376f295d1..bdd0a4574 100644
--- a/test/libcxx/utilities/meta/is_referenceable.pass.cpp
+++ b/test/libcxx/utilities/meta/is_referenceable.pass.cpp
@@ -189,4 +189,6 @@ static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) &&
 static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &&>::value), "");
 #endif
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
index 010f8f48d..80bd2e738 100644
--- a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
+++ b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
@@ -55,7 +55,7 @@ struct J
 };
 
 
-int main()
+int main(int, char**)
 {
     static_assert(std::__has_operator_addressof<int>::value == false, "");
     static_assert(std::__has_operator_addressof<A>::value == false, "");
@@ -65,4 +65,6 @@ int main()
     static_assert(std::__has_operator_addressof<G>::value == true, "");
     static_assert(std::__has_operator_addressof<H>::value == true, "");
     static_assert(std::__has_operator_addressof<J>::value == true, "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
index 0be653d7f..8606769ee 100644
--- a/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
+++ b/test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
@@ -15,7 +15,7 @@
 
 #include <type_traits>
 
-int main ()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_NO_IS_AGGREGATE
   // This should not compile when _LIBCPP_HAS_NO_IS_AGGREGATE is defined.
@@ -24,4 +24,6 @@ int main ()
 #else
 #error Forcing failure...
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/meta/version.pass.cpp b/test/libcxx/utilities/meta/version.pass.cpp
index 831ca6672..7f4cbd841 100644
--- a/test/libcxx/utilities/meta/version.pass.cpp
+++ b/test/libcxx/utilities/meta/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
index 47fb9d5ad..1f559904c 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -53,7 +53,7 @@ test()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -70,4 +70,6 @@ int main()
 
     static_assert(!(std::is_copy_assignable<optional<Z1>>::value), "");
     static_assert(!(std::is_copy_assignable<optional<Z2>>::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
index 5063d69c3..325bcb452 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -50,7 +50,7 @@ test()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -67,4 +67,6 @@ int main()
 
     static_assert(!(std::is_move_assignable<optional<Z1>>::value), "");
     static_assert(!(std::is_move_assignable<optional<Z2>>::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 50e27e99e..694ab0156 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -35,7 +35,7 @@ struct Z
     Z& operator=(const Z&) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -55,4 +55,6 @@ int main()
     static_assert(!(std::is_trivially_copy_constructible<optional<std::string>>::value), "");
 
     static_assert(!(std::is_copy_constructible<optional<Z>>::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index ff66a1ea9..383eaa986 100644
--- a/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -36,7 +36,7 @@ struct Z
     Z& operator=(const Z&) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -56,4 +56,6 @@ int main()
     static_assert(!(std::is_trivially_move_constructible<optional<std::string>>::value), "");
 
     static_assert(!(std::is_move_constructible<optional<Z>>::value), "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp b/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
index d09af830f..36f5bb937 100644
--- a/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
+++ b/test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
@@ -85,7 +85,7 @@ struct TrivialCopyNonTrivialMove {
     TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
 };
 
-int main()
+int main(int, char**)
 {
     sink(
         ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
@@ -94,4 +94,6 @@ int main()
         NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
         DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
     );
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/optional/version.pass.cpp b/test/libcxx/utilities/optional/version.pass.cpp
index 7dc36057c..49b263a37 100644
--- a/test/libcxx/utilities/optional/version.pass.cpp
+++ b/test/libcxx/utilities/optional/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/ratio/version.pass.cpp b/test/libcxx/utilities/ratio/version.pass.cpp
index a38c07515..112111c37 100644
--- a/test/libcxx/utilities/ratio/version.pass.cpp
+++ b/test/libcxx/utilities/ratio/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/template.bitset/includes.pass.cpp b/test/libcxx/utilities/template.bitset/includes.pass.cpp
index 78c39989f..3ec17b079 100644
--- a/test/libcxx/utilities/template.bitset/includes.pass.cpp
+++ b/test/libcxx/utilities/template.bitset/includes.pass.cpp
@@ -26,6 +26,8 @@
 #error <iosfwd> has not been included
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/template.bitset/version.pass.cpp b/test/libcxx/utilities/template.bitset/version.pass.cpp
index 9cb31d5fe..94df4d1ba 100644
--- a/test/libcxx/utilities/template.bitset/version.pass.cpp
+++ b/test/libcxx/utilities/template.bitset/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
index 8ea12b712..ed49ac286 100644
--- a/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // asctime is not thread-safe.
     std::time_t t = 0;
     std::asctime(&t);
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
index 3e1986bf4..741de667e 100644
--- a/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // ctime is not thread-safe.
     std::time_t t = 0;
     std::ctime(&t);
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
index 979c92fbd..ce7f78203 100644
--- a/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // gmtime is not thread-safe.
     std::time_t t = 0;
     std::gmtime(&t);
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp b/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
index a68a5c33f..8f803d91c 100644
--- a/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
+++ b/test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // localtime is not thread-safe.
     std::time_t t = 0;
     std::localtime(&t);
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/time/version.pass.cpp b/test/libcxx/utilities/time/version.pass.cpp
index 2e3373711..d1093dd4a 100644
--- a/test/libcxx/utilities/time/version.pass.cpp
+++ b/test/libcxx/utilities/time/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
index 76cb442b2..209382087 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
@@ -20,7 +20,7 @@ struct A {};
 
 struct B {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int, A> T;
@@ -42,4 +42,6 @@ int main()
         typedef std::tuple<int, A, B> T;
         static_assert((sizeof(T) == sizeof(int)), "");
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
index d1a371b5d..a4c43ba5d 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
@@ -43,7 +43,7 @@ template <class ...Args>
 void F(typename CannotDeduce<std::tuple<Args...>>::type const&) {}
 
 
-int main() {
+int main(int, char**) {
 #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)
   // Test that we emit our diagnostic from the library.
   // expected-error@tuple:* 8 {{"Attempted construction of reference element binds to a temporary whose lifetime has ended"}}
@@ -81,4 +81,6 @@ int main() {
 #error force failure
 // expected-error@-1 {{force failure}}
 #endif
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
index 2eb85c666..8e4cb52bf 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
@@ -77,7 +77,7 @@ void test_example_from_docs() {
   assert(std::get<2>(tup) == std::error_code{});
 }
 
-int main()
+int main(int, char**)
 {
     {
         using E = MoveOnly;
@@ -104,4 +104,6 @@ int main()
     // constructor extensions.
     test_default_constructible_extension_sfinae();
     test_example_from_docs();
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
index 12d226855..f012d4c5f 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
@@ -89,7 +89,7 @@ void test_example_from_docs() {
   assert(std::get<2>(tup) == std::error_code{});
 }
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -113,4 +113,6 @@ int main()
     // constructor extensions.
     test_default_constructible_extension_sfinae();
     test_example_from_docs();
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/tuple/version.pass.cpp b/test/libcxx/utilities/tuple/version.pass.cpp
index 8149eb07e..28232a99b 100644
--- a/test/libcxx/utilities/tuple/version.pass.cpp
+++ b/test/libcxx/utilities/tuple/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/type.index/version.pass.cpp b/test/libcxx/utilities/type.index/version.pass.cpp
index 94a1ebf43..38cd0254a 100644
--- a/test/libcxx/utilities/type.index/version.pass.cpp
+++ b/test/libcxx/utilities/type.index/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp b/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
index 853082012..a2559f208 100644
--- a/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
+++ b/test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
@@ -14,7 +14,7 @@
 
 struct S {};
 
-int main() {
+int main(int, char**) {
   using I = std::in_place_index_t<0>;
   static_assert( std::__is_inplace_index<I>::value, "");
   static_assert( std::__is_inplace_index<const I>::value, "");
@@ -30,4 +30,6 @@ int main() {
   static_assert(!std::__is_inplace_index<void>::value, "");
   static_assert(!std::__is_inplace_index<int>::value, "");
   static_assert(!std::__is_inplace_index<S>::value, "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp b/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
index 9a6739c27..534fb5059 100644
--- a/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
+++ b/test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
@@ -14,7 +14,7 @@
 
 struct S {};
 
-int main() {
+int main(int, char**) {
   using T = std::in_place_type_t<int>;
   static_assert( std::__is_inplace_type<T>::value, "");
   static_assert( std::__is_inplace_type<const T>::value, "");
@@ -30,4 +30,6 @@ int main() {
   static_assert(!std::__is_inplace_type<void>::value, "");
   static_assert(!std::__is_inplace_type<int>::value, "");
   static_assert(!std::__is_inplace_type<S>::value, "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
index 6e65d9b52..e03fa6d7f 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
@@ -37,7 +37,7 @@ struct ImplicitNothrowT {
     int value;
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>, int, int>::value, "");
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitNothrowT, ExplicitT>, int, int>::value, "");
@@ -50,4 +50,6 @@ int main() {
         static_assert(!std::is_nothrow_constructible<std::pair<ImplicitT, ImplicitNothrowT>, int, int>::value, "");
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>, int, int>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
index 17a2b5a41..5765700fe 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
@@ -27,7 +27,7 @@
 #pragma clang diagnostic ignored "-Wmissing-braces"
 #endif
 
-int main()
+int main(int, char**)
 {
     using C = TestTypes::TestType;
     {
@@ -100,4 +100,6 @@ int main()
        assert(p.first.value == 42);
        assert(p.second.value == -42);
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
index 923bd0dd6..a2fac173e 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
@@ -37,7 +37,7 @@ struct ImplicitNothrowT {
     ImplicitNothrowT(ImplicitNothrowT const&) noexcept {}
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>,
                                                      ExplicitT const&, ExplicitT const&>::value, "");
@@ -58,4 +58,6 @@ int main() {
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>,
                                                      ImplicitNothrowT const&, ImplicitNothrowT const&>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
index 68d294bd6..16d714ab9 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -39,7 +39,7 @@ struct ImplicitNothrowT {
     int value;
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>,
                                                      std::pair<int, int> const&>::value, "");
@@ -60,4 +60,6 @@ int main() {
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>,
                                                      std::pair<int, int> const&>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
index efd7fcb40..a7f0f8764 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -26,10 +26,12 @@ struct NonThrowingDefault {
   NonThrowingDefault() noexcept { }
 };
 
-int main() {
+int main(int, char**) {
 
     static_assert(!std::is_nothrow_default_constructible<std::pair<ThrowingDefault, ThrowingDefault>>::value, "");
     static_assert(!std::is_nothrow_default_constructible<std::pair<NonThrowingDefault, ThrowingDefault>>::value, "");
     static_assert(!std::is_nothrow_default_constructible<std::pair<ThrowingDefault, NonThrowingDefault>>::value, "");
     static_assert( std::is_nothrow_default_constructible<std::pair<NonThrowingDefault, NonThrowingDefault>>::value, "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
index 076505b46..00c1910a3 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
@@ -158,7 +158,8 @@ void test_layout() {
     static_assert(offsetof(PairT, first) == 0, "");
 }
 
-int main() {
+int main(int, char**) {
     test_trivial();
     test_layout();
+    return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
index fa5f2b6d5..5be63dd92 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
@@ -14,11 +14,13 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, double> P;
     std::tuple_element<2, P>::type foo; // expected-note {{requested here}}
         // expected-error-re@utility:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < 2')?}} "Index out of bounds in std::tuple_element<std::pair<T1, T2>>"}}
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
index 2c636182f..e4c953840 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
@@ -23,7 +23,7 @@
 #include "archetypes.hpp"
 
 
-int main() {
+int main(int, char**) {
     using NonThrowingConvert = NonThrowingTypes::ConvertingType;
     using ThrowingConvert = NonTrivialTypes::ConvertingType;
     static_assert(!std::is_nothrow_constructible<std::pair<ThrowingConvert, ThrowingConvert>,
@@ -34,4 +34,6 @@ int main() {
                                                  std::piecewise_construct_t, std::tuple<int, int>, std::tuple<long, long>>::value, "");
     static_assert( std::is_nothrow_constructible<std::pair<NonThrowingConvert, NonThrowingConvert>,
                                                  std::piecewise_construct_t, std::tuple<int, int>, std::tuple<long, long>>::value, "");
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
index c64b92107..8cc83f7bd 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -38,7 +38,7 @@ struct ImplicitNothrowT {
     int value;
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>,
                                                      std::pair<int, int>&&>::value, "");
@@ -59,4 +59,6 @@ int main() {
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>,
                                                      std::pair<int, int>&&>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
index 39d3365aa..1086011c3 100644
--- a/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
+++ b/test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
@@ -153,7 +153,8 @@ void test_layout() {
     static_assert(offsetof(PairT, first) == 0, "");
 }
 
-int main() {
+int main(int, char**) {
     test_trivial();
     test_layout();
+    return 0;
 }
diff --git a/test/libcxx/utilities/utility/version.pass.cpp b/test/libcxx/utilities/utility/version.pass.cpp
index bd64d6e5a..ca783db7f 100644
--- a/test/libcxx/utilities/utility/version.pass.cpp
+++ b/test/libcxx/utilities/utility/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp b/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
index 224902828..fd23d5b94 100644
--- a/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
+++ b/test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
@@ -25,11 +25,13 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::variant<int, double> T;
         std::variant_alternative<2, T>::type foo; // expected-note {{requested here}}
         // expected-error-re@variant:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}} "Index out of bounds in std::variant_alternative<>"}}
     }
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
index 43cb302f9..1bfe0e9fd 100644
--- a/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
+++ b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
@@ -59,10 +59,12 @@ void test_index_internals() {
   static_assert(std::__variant_npos<IndexT> == IndexLim::max(), "");
 }
 
-int main() {
+int main(int, char**) {
   test_index_type<unsigned char>();
   // This won't compile due to template depth issues.
   //test_index_type<unsigned short>();
   test_index_internals<unsigned char>();
   test_index_internals<unsigned short>();
+
+  return 0;
 }
diff --git a/test/libcxx/utilities/variant/version.pass.cpp b/test/libcxx/utilities/variant/version.pass.cpp
index c614ee472..3ef8ed50c 100644
--- a/test/libcxx/utilities/variant/version.pass.cpp
+++ b/test/libcxx/utilities/variant/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/nothing_to_do.pass.cpp b/test/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/nothing_to_do.pass.cpp
+++ b/test/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp b/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
+++ b/test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
index c18550a16..9dcace7a0 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
@@ -46,7 +46,7 @@ test()
         assert(ia[i] == ib[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -86,4 +86,6 @@ int main()
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
index bed5ff636..3b20fbde5 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
@@ -49,7 +49,7 @@ test()
         assert(ia[i] == ib[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
@@ -66,4 +66,6 @@ int main()
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
index 3d29d6297..903bcbe6c 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
@@ -53,7 +53,7 @@ test()
         assert(ib[i] % 3 == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -93,4 +93,6 @@ int main()
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
index 540211752..2e181cfd4 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
@@ -49,7 +49,7 @@ test()
         assert(ia[i] == ib[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -89,4 +89,6 @@ int main()
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
index bc6a2c80e..da56ec30f 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
@@ -56,7 +56,7 @@ test_int()
     assert(ia[3] == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test_char<forward_iterator<char*> >();
     test_char<bidirectional_iterator<char*> >();
@@ -71,4 +71,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
index a133ba63b..e774c915f 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
@@ -148,7 +148,7 @@ void test6()
 }
 
 
-int main()
+int main(int, char**)
 {
     test_char<forward_iterator<char*> >();
     test_char<bidirectional_iterator<char*> >();
@@ -170,4 +170,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
index 4830ea501..29d32d715 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
@@ -51,7 +51,7 @@ test()
     assert(ia[3] == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -61,4 +61,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
index 5b6712d44..4ffdc648f 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
@@ -74,7 +74,7 @@ test()
     test2<Iter, long double>();
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -84,4 +84,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
index cab5e5a4e..cdb126d49 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -54,7 +54,7 @@ test1()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -127,4 +127,6 @@ int main()
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
index f9a6e77c8..365c1a115 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -54,7 +54,7 @@ test1()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
@@ -81,4 +81,6 @@ int main()
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
index 460cc5e05..6c741490f 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
@@ -35,7 +35,7 @@ TEST_CONSTEXPR bool test_constexpr() {
 #endif
 
 
-int main() {
+int main(int, char**) {
   {
     const int ia[] = {1, 2, 3, 4, 5, 6};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
@@ -94,4 +94,6 @@ int main() {
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
index c3749868b..97af585b9 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
@@ -93,9 +93,11 @@ test()
         assert(!is_odd()(*i));
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
index fcfcc7c79..267136346 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
@@ -43,7 +43,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {1, 2, 3, 4, 6, 8, 5, 7};
@@ -68,4 +68,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
index e6dd5c041..5da1b8150 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
@@ -35,7 +35,7 @@ TEST_CONSTEXPR bool test_constexpr() {
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {2, 4, 6, 8, 10};
@@ -89,4 +89,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
index 7e886576f..0358f7030 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
@@ -301,7 +301,7 @@ test1()
 
 #endif  // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<std::pair<int,int>*> >();
     test<random_access_iterator<std::pair<int,int>*> >();
@@ -310,4 +310,6 @@ int main()
 #if TEST_STD_VER >= 11
     test1<bidirectional_iterator<std::unique_ptr<int>*> >();
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
index a9aa64e48..c01104c0c 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
@@ -32,9 +32,11 @@ template <class PopulationIterator, class SampleIterator> void test() {
                             SampleIterator(oa), os, g);
 }
 
-int main() {
+int main(int, char**) {
   // expected-error-re@algorithm:* {{static_assert failed{{( due to requirement '.*')?}} "SampleIterator must meet the requirements of RandomAccessIterator"}}
   // expected-error@algorithm:* 2 {{does not provide a subscript operator}}
   // expected-error@algorithm:* {{invalid operands}}
   test<input_iterator<int *>, output_iterator<int *> >();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
index bfc71e779..40f2037f0 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
@@ -136,7 +136,7 @@ void test_small_population() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test<input_iterator, int, random_access_iterator, int>();
   test<forward_iterator, int, output_iterator, int>();
   test<forward_iterator, int, random_access_iterator, int>();
@@ -156,4 +156,6 @@ int main() {
   test_small_population<input_iterator, int, random_access_iterator, int>();
   test_small_population<forward_iterator, int, output_iterator, int>();
   test_small_population<forward_iterator, int, random_access_iterator, int>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
index aa7c74788..58e608462 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
@@ -48,7 +48,9 @@ void test_stability(bool expect_stable) {
   assert(expect_stable == !unstable);
 }
 
-int main() {
+int main(int, char**) {
   test_stability<forward_iterator<int *>, output_iterator<int *> >(true);
   test_stability<input_iterator<int *>, random_access_iterator<int *> >(false);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
index 6ae7eb964..cb83cde93 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
@@ -39,7 +39,7 @@ test_with_iterator()
 }
 
 
-int main()
+int main(int, char**)
 {
     int ia[]  = {1, 2, 3, 4};
     int ia1[] = {1, 4, 3, 2};
@@ -57,4 +57,5 @@ int main()
     test_with_iterator<random_access_iterator<int*> >();
     test_with_iterator<int*>();
 
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
index ffdb098fc..dd5398dac 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
@@ -51,8 +51,9 @@ test_with_iterator()
 }
 
 
-int main()
+int main(int, char**)
 {
     test_with_iterator<random_access_iterator<int*> >();
     test_with_iterator<int*>();
-}
\ No newline at end of file
+    return 0;
+}
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
index 865eb4887..d5f162bce 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     int ia1[] = {2, 7, 1, 4, 3, 6, 5, 10, 9, 8};
@@ -31,4 +31,6 @@ int main()
     std::shuffle(ia, ia+sa, std::move(g));
     LIBCPP_ASSERT(std::equal(ia, ia+sa, ia2));
     assert(std::is_permutation(ia, ia+sa, ia2));
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
index 3c7651189..ebacec5f4 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
@@ -73,7 +73,7 @@ test1()
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -90,4 +90,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
index ab8d6d886..8dedddb4c 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
@@ -50,7 +50,7 @@ test()
     assert(ib[5] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -85,4 +85,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
index c4ad12fa8..7d10c6bd7 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
@@ -55,7 +55,7 @@ test()
     assert(ib[5] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -90,4 +90,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
index 35771b5a0..637a91707 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
@@ -88,7 +88,7 @@ test1()
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -105,4 +105,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
index 2f9dc692a..1e91fc968 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
@@ -47,7 +47,7 @@ test()
     assert(ia[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -57,4 +57,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
index a7e38b92b..da3fabf40 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
@@ -54,7 +54,7 @@ test()
     assert(ib[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -89,4 +89,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
index 3daf1109f..26cbd705f 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
@@ -58,7 +58,7 @@ test()
     assert(ib[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -93,4 +93,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
index d35927a1a..4f32b6e94 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
@@ -50,7 +50,7 @@ test()
     assert(ia[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -60,4 +60,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
index d39da5405..7838a0ca2 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
@@ -51,9 +51,11 @@ test()
     assert(id[3] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
index 4758c4f1e..6967c446b 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
@@ -72,7 +72,7 @@ test()
     assert(jd[3] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, output_iterator<int*> >();
     test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
@@ -95,4 +95,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
index a588b971c..007faf685 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
@@ -419,7 +419,7 @@ test1()
 
 #endif  // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -434,4 +434,6 @@ int main()
     test1<std::unique_ptr<int>*>();
 
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
index 5f71e0940..d66bf8caa 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
@@ -128,7 +128,7 @@ test()
     assert(ib[3] == 3);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, output_iterator<int*> >();
     test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
@@ -151,4 +151,6 @@ int main()
 // #if TEST_STD_VER > 17
 //    static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
index 182b17914..419bb4bbb 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
@@ -16,11 +16,13 @@
 #include <algorithm>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int i = 1;
     int j = 2;
     std::iter_swap(&i, &j);
     assert(i == 2);
     assert(j == 1);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
index 43cd4ce63..a47bbd24d 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
@@ -105,7 +105,7 @@ void test2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*>, forward_iterator<int*> >();
     test<forward_iterator<int*>, bidirectional_iterator<int*> >();
@@ -150,4 +150,6 @@ int main()
 #endif // TEST_STD_VER >= 11
 
     test2();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
index dc8101a25..ca7287bf2 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
@@ -56,7 +56,7 @@ test()
     assert(ib[4] == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
@@ -236,4 +236,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
index 9fc25adc3..85c386820 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
@@ -57,7 +57,7 @@ test()
     assert(ib[4] == 5);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -97,4 +97,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
index 680633745..7046d6a2b 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
@@ -181,7 +181,7 @@ test1()
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -198,4 +198,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
index 3c34a9a31..ba533507c 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
@@ -105,7 +105,7 @@ test()
     assert(ji[2] == 2);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -140,4 +140,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
index b91c05e76..e8ebeaead 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
@@ -133,7 +133,7 @@ test()
     assert(count_equal::count == si-1);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -168,4 +168,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
index d48bb6a67..9f0c695e2 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
@@ -223,7 +223,7 @@ test1()
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -240,4 +240,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp b/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
index de03da4ba..6d57c5869 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
@@ -30,7 +30,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -47,4 +47,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
index a542cb81f..c80bc9fff 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
@@ -34,7 +34,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -54,4 +54,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
index 61f6c2cee..5c49878f6 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
@@ -36,7 +36,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int ia[] = {2, 4, 6, 8};
@@ -58,4 +58,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
index ea9f8a4c8..22ae581d6 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
@@ -36,7 +36,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int ia[] = {2, 4, 6, 8};
@@ -66,4 +66,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
index f2e93719e..d864080df 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
@@ -29,7 +29,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -43,4 +43,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
index 7f6be6a27..978f5fcdb 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
@@ -36,7 +36,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -53,4 +53,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
index 81d46ce62..afd57491a 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
@@ -44,7 +44,7 @@ TEST_CONSTEXPR bool test_constexpr() {
 #endif
 
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -88,4 +88,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
index 03de33a6b..2b9619b73 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
@@ -58,7 +58,7 @@ bool counting_equals ( const T &a, const T &b ) {
     return a == b;
 }
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -114,4 +114,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
index 36633ee12..3060528a8 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
@@ -62,7 +62,7 @@ test()
     assert(std::find_end(Iter1(ia), Iter1(ia), Iter2(b), Iter2(b+1)) == Iter1(ia));
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -77,4 +77,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
index 2b3ca1b04..7358cf5f7 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
@@ -92,7 +92,7 @@ test()
     assert(count_equal::count <= 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -107,4 +107,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
index 1df8c1b82..04468f741 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
@@ -38,7 +38,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -69,4 +69,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
index cb64ee80a..3c32aee0e 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
@@ -40,7 +40,7 @@ constexpr bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -75,4 +75,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
index de7a4181c..9dc265f18 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
@@ -29,7 +29,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -42,4 +42,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
index 7b0ae435a..6151a55b8 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
@@ -37,7 +37,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -53,4 +53,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
index 90e952171..36a754269 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
@@ -37,7 +37,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -53,4 +53,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
index b43acc13a..f4dcd2d57 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
@@ -40,7 +40,7 @@ struct for_each_test
     void operator()(int& i) {++i; ++count;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef input_iterator<int*> Iter;
     int ia[] = {0, 1, 2, 3, 4, 5};
@@ -76,4 +76,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
index 66336b2f9..4d129e755 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
@@ -37,7 +37,7 @@ struct for_each_test
     void operator()(int& i) {++i; ++count;}
 };
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -51,4 +51,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
index 3173276d1..2a2c796ca 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
@@ -35,7 +35,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {0};
@@ -618,4 +618,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
index 914eccdcd..ea4270ec4 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
@@ -55,7 +55,7 @@ struct eq {
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {0};
@@ -769,4 +769,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
index c77ffb220..f3a4fea90 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
@@ -36,7 +36,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int ia[] = {2, 4, 6, 8};
@@ -66,4 +66,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
index a3fedafdc..5aaa832de 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
@@ -95,7 +95,7 @@ test()
     assert(std::search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk)) == Iter1(ij+6));
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -121,4 +121,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
index 50d710e67..3c86127f3 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
@@ -79,7 +79,7 @@ test()
     (void)std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(0), 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -88,4 +88,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
index befa432bf..135689390 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
@@ -158,7 +158,7 @@ test()
     count_equal::count = 0;
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -167,4 +167,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
index e61f7f9f0..f835d2f09 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
@@ -110,7 +110,7 @@ test()
     assert(count_equal::count <= sh*3);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -125,4 +125,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
index 74502d631..72281b47f 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
@@ -58,7 +58,7 @@ TEST_CONSTEXPR bool test_constexpr() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -89,4 +89,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
index 2b21daab0..15edec03a 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -68,7 +68,7 @@ TEST_CONSTEXPR bool test_constexpr() {
 #define HAS_FOUR_ITERATOR_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -114,4 +114,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp b/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
index 45c50ed01..3d04d5161 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
@@ -61,7 +61,7 @@ test()
     test(Iter(v.data()), Iter(v.data()+v.size()), M, false);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 2, 4, 6};
     for (int* e = d; e <= d+4; ++e)
@@ -76,4 +76,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
index 75d7a64a3..a447853d2 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
@@ -62,7 +62,7 @@ test()
     test(Iter(v.data()), Iter(v.data()+v.size()), M, false);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {6, 4, 2, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -77,4 +77,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
index e8b159832..e22bd5ad2 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
@@ -69,7 +69,7 @@ test()
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 1, 2, 3};
     for (int* e = d; e <= d+4; ++e)
@@ -84,4 +84,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
index b7b43a829..ab36e7033 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
@@ -68,7 +68,7 @@ test()
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {3, 2, 1, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -83,4 +83,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
index 8f99ed99e..ce9b71c06 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
@@ -64,7 +64,7 @@ test()
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 1, 2, 3};
     for (int* e = d; e <= d+4; ++e)
@@ -79,4 +79,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
index 0190e0f21..b9133028d 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
@@ -64,7 +64,7 @@ test()
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {3, 2, 1, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -79,4 +79,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
index 6748b5ec4..1f9babde5 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
@@ -61,7 +61,7 @@ test()
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 1, 2, 3};
     for (int* e = d; e <= d+4; ++e)
@@ -76,4 +76,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
index 5cbb01abe..86066a620 100644
--- a/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
@@ -64,7 +64,7 @@ test()
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {3, 2, 1, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -79,4 +79,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
index 4fd10376f..482af9ef3 100644
--- a/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
@@ -38,7 +38,7 @@ test(const T& v, const T& lo, const T& hi, C c, const T& x)
     assert(&std::clamp(v, lo, hi, c) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -123,4 +123,6 @@ int main()
     static_assert(std::clamp(x, y, z, std::greater<T>()) == y, "" );
     static_assert(std::clamp(y, x, z, std::greater<T>()) == y, "" );
     }
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
index 96c3b43df..4066a3945 100644
--- a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
@@ -36,7 +36,7 @@ test(const T& a, const T& lo, const T& hi, const T& x)
     assert(&std::clamp(a, lo, hi) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -121,4 +121,6 @@ int main()
     static_assert(std::clamp(x, y, z) == x, "" );
     static_assert(std::clamp(y, x, z) == x, "" );
     }
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
index ec78c10af..14b1d1754 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
@@ -525,11 +525,13 @@ void test()
     assert(std::is_heap(i246, i246+7) == (std::is_heap_until(i246, i246+7) == i246+7));
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
index b48db5423..9e3445882 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
@@ -526,11 +526,13 @@ void test()
     assert(std::is_heap(i246, i246+7, std::greater<int>()) == (std::is_heap_until(i246, i246+7, std::greater<int>()) == i246+7));
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
index 78eb5dd70..b9bb3e1f5 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
@@ -525,11 +525,13 @@ void test()
     assert(std::is_heap_until(i246, i246+7) == i246+7);
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
index 21b21deca..6002f662e 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
@@ -526,11 +526,13 @@ void test()
     assert(std::is_heap_until(i246, i246+7, std::greater<int>()) == i246+6);
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
index 9d2bb6e23..3d862ca4f 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
@@ -30,7 +30,7 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -38,4 +38,6 @@ int main()
     test(3);
     test(10);
     test(1000);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
index 18fffd41e..0650f7454 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
@@ -74,7 +74,7 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -97,4 +97,6 @@ int main()
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
index 1f26f6d15..2b434983c 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
@@ -35,7 +35,9 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
index 74474be43..63bd1520f 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
@@ -47,7 +47,7 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
 
@@ -67,4 +67,6 @@ int main()
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
index d7f681ede..7db79e3bc 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
@@ -34,7 +34,9 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
index 536a2687a..4a47f65bf 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
@@ -45,7 +45,7 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
 
@@ -64,4 +64,6 @@ int main()
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
index cae2c0d9b..947affcf0 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
@@ -31,7 +31,7 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -39,4 +39,6 @@ int main()
     test(3);
     test(10);
     test(1000);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
index 8bad526bb..151373b71 100644
--- a/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
@@ -42,7 +42,7 @@ void test(int N)
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -64,4 +64,6 @@ int main()
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
index 096c58ce0..f421bfcb8 100644
--- a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
@@ -46,7 +46,7 @@ test()
     assert(!std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa)));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -81,4 +81,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
index 50050c50a..b0e0ee7d7 100644
--- a/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
@@ -51,7 +51,7 @@ test()
     assert( std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa), c));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -86,4 +86,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
index ebe730728..208221416 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
@@ -96,7 +96,7 @@ test()
     test<Iter>(1000);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
@@ -107,4 +107,6 @@ int main()
     test<random_access_iterator<S*> >();
     test<S*>();
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
index ce26335cb..7ab5c0ca9 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -135,7 +135,7 @@ void test_PR31166 ()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
@@ -167,4 +167,6 @@ int main()
 #endif  // TEST_STD_VER >= 11
 
     test_PR31166();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
index f373f0494..6c6f0c46d 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
@@ -89,7 +89,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -245,4 +245,6 @@ int main()
 //  Not yet - waiting on std::copy
 //     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
index c4fd0746b..508a4f5ab 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
@@ -100,7 +100,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -256,4 +256,6 @@ int main()
 //  Not yet - waiting on std::copy
 //     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
index 773e14c46..f52c72b14 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
@@ -24,7 +24,7 @@ test(const T& a, const T& b, const T& x)
     assert(&std::max(a, b) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -52,4 +52,6 @@ int main()
     static_assert(std::max(y, x) == x, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
index 8488f7003..e554b3cd0 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
@@ -26,7 +26,7 @@ test(const T& a, const T& b, C c, const T& x)
     assert(&std::max(a, b, c) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -54,4 +54,6 @@ int main()
     static_assert(std::max(y, x, std::greater<int>()) == y, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
index c6e9e634b..cb5341ca0 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
@@ -71,7 +71,7 @@ void constexpr_test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -79,4 +79,6 @@ int main()
     test<const int*>();
 
     constexpr_test ();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
index 0a7d6ef6a..fbcea97b6 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
@@ -91,7 +91,7 @@ void constexpr_test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -100,4 +100,6 @@ int main()
     test_eq();
 
     constexpr_test();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
index 560051e31..ff58ba479 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::max({2, 3, 1});
     assert(i == 3);
@@ -40,4 +40,6 @@ int main()
     static_assert(std::max({3, 2, 1}) == 3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
index 0cdab3aa4..4042f48af 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::max({2, 3, 1}, std::greater<int>());
     assert(i == 1);
@@ -41,4 +41,6 @@ int main()
     static_assert(std::max({3, 2, 1}, std::greater<int>()) == 1, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
index a34cb31e7..533077a55 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
@@ -24,7 +24,7 @@ test(const T& a, const T& b, const T& x)
     assert(&std::min(a, b) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -52,4 +52,6 @@ int main()
     static_assert(std::min(y, x) == y, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
index 4a815dc0b..4524fe47b 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
@@ -26,7 +26,7 @@ test(const T& a, const T& b, C c, const T& x)
     assert(&std::min(a, b, c) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -54,4 +54,6 @@ int main()
     static_assert(std::min(y, x, std::greater<int>()) == x, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
index b208096d4..151bfa812 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
@@ -71,7 +71,7 @@ void constexpr_test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -79,4 +79,6 @@ int main()
     test<const int*>();
 
     constexpr_test();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
index 89a9227bd..cada8b346 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
@@ -91,7 +91,7 @@ void constexpr_test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -100,4 +100,6 @@ int main()
     test_eq();
 
     constexpr_test();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
index ba8da8dfa..1253e1a6f 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::min({2, 3, 1});
     assert(i == 1);
@@ -40,4 +40,6 @@ int main()
     static_assert(std::min({3, 2, 1}) == 1, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
index e5f372367..b0bd5d492 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::min({2, 3, 1}, std::greater<int>());
     assert(i == 3);
@@ -41,4 +41,6 @@ int main()
     static_assert(std::min({3, 2, 1}, std::greater<int>()) == 3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
index e7c2ffd5f..0dffd5274 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
@@ -26,7 +26,7 @@ test(const T& a, const T& b, const T& x, const T& y)
     assert(&p.second == &y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -60,4 +60,6 @@ int main()
     static_assert(p2.second == x, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
index 8eb059119..38ee5a96e 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
@@ -29,7 +29,7 @@ test(const T& a, const T& b, C c, const T& x, const T& y)
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -63,4 +63,6 @@ int main()
     static_assert(p2.second == y, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
index 14e7b0c06..8b56ac180 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
@@ -89,7 +89,7 @@ void constexpr_test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -97,4 +97,6 @@ int main()
     test<const int*>();
 
    constexpr_test();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
index ba7912ed3..3ecc02ce1 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
@@ -96,7 +96,7 @@ void constexpr_test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -104,4 +104,6 @@ int main()
     test<const int*>();
 
     constexpr_test();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
index 477a0b893..e02b9fb38 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert((std::minmax({1, 2, 3}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({1, 3, 2}) == std::pair<int, int>(1, 3)));
@@ -37,4 +37,6 @@ int main()
     static_assert((std::minmax({3, 2, 1}) == std::pair<int, int>(1, 3)), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
index 0b834257a..efa0e92fb 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
@@ -35,7 +35,7 @@ void test_all_equal(std::initializer_list<int> il)
     assert(pred.count() <= ((3 * il.size()) / 2));
 }
 
-int main()
+int main(int, char**)
 {
     assert((std::minmax({1, 2, 3}, std::greater<int>()) == std::pair<int, int>(3, 1)));
     assert((std::minmax({1, 3, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
@@ -72,4 +72,6 @@ int main()
     static_assert((std::minmax({3, 2, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp b/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
index d19304458..e04850175 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
@@ -16,7 +16,7 @@
 
 #include "test_iterators.h"
 
-int main() {
+int main(int, char**) {
   int arr[] = {1, 2, 3};
   const int *b = std::begin(arr), *e = std::end(arr);
   typedef input_iterator<const int*> Iter;
@@ -33,4 +33,6 @@ int main() {
     std::minmax_element(Iter(b), Iter(e));
   }
 
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
index b331239f1..abde620d0 100644
--- a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
@@ -50,7 +50,7 @@ test(int N)
     test_one(N, N-1);
 }
 
-int main()
+int main(int, char**)
 {
     int d = 0;
     std::nth_element(&d, &d, &d);
@@ -62,4 +62,6 @@ int main()
     test(997);
     test(1000);
     test(1009);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
index 5f4639427..980b2b988 100644
--- a/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
@@ -63,7 +63,7 @@ test(int N)
     test_one(N, N-1);
 }
 
-int main()
+int main(int, char**)
 {
     int d = 0;
     std::nth_element(&d, &d, &d);
@@ -85,4 +85,6 @@ int main()
     assert(static_cast<std::size_t>(*v[v.size()/2]) == v.size()/2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
index 74cd21c5c..62d5b42e2 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
@@ -57,9 +57,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
index fed1a2c51..4416ed1e4 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
@@ -59,9 +59,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
index 6f11ebda0..044a6444a 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
@@ -57,9 +57,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
index 1c78728a5..760daae36 100644
--- a/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
@@ -59,9 +59,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
index 72f80df56..f8e888408 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
@@ -62,7 +62,7 @@ test()
     assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4)));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -97,4 +97,6 @@ int main()
 #if TEST_STD_VER > 17
    static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
index 5d959a0a8..48bafcb3a 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
@@ -65,7 +65,7 @@ test()
     assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4), std::less<int>()));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -100,4 +100,6 @@ int main()
 #if TEST_STD_VER > 17
    static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
index 576b2889a..4d1f537b7 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
@@ -45,7 +45,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), irr, irr+srr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -196,4 +196,6 @@ int main()
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
index 8b2f1c049..2597174c6 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
@@ -47,7 +47,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), irr, irr+srr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -198,4 +198,6 @@ int main()
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
index 84b5aa0a9..08e08f672 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
@@ -62,7 +62,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -217,4 +217,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
index 0511d77f8..acdd7b019 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
@@ -65,7 +65,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -220,4 +220,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
index e869169b3..c74d6623b 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
@@ -44,7 +44,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -195,4 +195,6 @@ int main()
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
index a429e59bb..99e75b122 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
@@ -48,7 +48,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -199,4 +199,6 @@ int main()
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
index bc5175438..827c2c190 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
@@ -43,7 +43,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -194,4 +194,6 @@ int main()
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
index 8ce76754c..c8d1d2882 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
@@ -45,7 +45,7 @@ test()
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -196,4 +196,6 @@ int main()
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
index 7af3f23ff..45bd455bb 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
@@ -28,7 +28,7 @@
 #include "MoveOnly.h"
 
 
-int main()
+int main(int, char**)
 {
     std::vector<MoveOnly> lhs, rhs;
     lhs.push_back(MoveOnly(2));
@@ -42,4 +42,6 @@ int main()
 
     assert(res.size() == 1);
     assert(res[0].get() == 2);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
index f500aeb0c..6e2ea5f3a 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
@@ -182,7 +182,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -192,4 +192,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
index 5a490977b..c5624d994 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
@@ -183,7 +183,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -193,4 +193,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
index 726772c5b..4396a4fc8 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
@@ -182,7 +182,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -192,4 +192,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
index cb20c0cba..48696cf08 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
@@ -183,7 +183,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -193,4 +193,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
index ddea611b1..45a6fef67 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
@@ -75,7 +75,7 @@ test()
     test_larger_sorts<Iter>(1009);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::partial_sort_copy(&i, &i, &i, &i+5);
@@ -85,4 +85,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
index d3e30b9d0..a1c2b0f9c 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
@@ -79,7 +79,7 @@ test()
     test_larger_sorts<Iter>(1009);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::partial_sort_copy(&i, &i, &i, &i+5);
@@ -89,4 +89,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
index 7e52c5747..b41eb12d6 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
@@ -53,7 +53,7 @@ test_larger_sorts(int N)
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::partial_sort(&i, &i, &i);
@@ -66,4 +66,6 @@ int main()
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
index e1143f592..f50d04005 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
@@ -66,7 +66,7 @@ test_larger_sorts(int N)
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int i = 0;
@@ -92,4 +92,6 @@ int main()
         assert(*v[i] == i);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
index c65f13c07..8f2845732 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
@@ -130,7 +130,7 @@ test_larger_sorts(int N)
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     // test null range
     int d = 0;
@@ -152,4 +152,6 @@ int main()
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
index e6896bea4..832d190ce 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
@@ -30,7 +30,7 @@ struct indirect_less
         {return *x < *y;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> v(1000);
@@ -53,4 +53,6 @@ int main()
     assert(*v[2] == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
index 9341d6994..c433baab4 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
@@ -130,7 +130,7 @@ test_larger_sorts(int N)
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     // test null range
     int d = 0;
@@ -152,4 +152,6 @@ int main()
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
index 6c5dcabfe..8da2b964b 100644
--- a/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
@@ -66,7 +66,7 @@ void test()
     assert(std::is_sorted(v.begin(), v.end()));
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
@@ -82,4 +82,6 @@ int main()
     assert(*v[2] == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp b/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp b/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
+++ b/test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp b/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
index ae4af5c97..bf5325940 100644
--- a/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
+++ b/test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
@@ -14,7 +14,9 @@
 
 #include <atomic>
 
-int main()
+int main(int, char**)
 {
     std::atomic_signal_fence(std::memory_order_seq_cst);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp b/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
index 91aeff282..d237f2de1 100644
--- a/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
+++ b/test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
@@ -14,7 +14,9 @@
 
 #include <atomic>
 
-int main()
+int main(int, char**)
 {
     std::atomic_thread_fence(std::memory_order_seq_cst);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
index 846d86e7a..23cb3d2b6 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -34,4 +34,6 @@ int main()
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
index 104c22b57..d87291297 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f; // uninitialized first
@@ -62,4 +62,6 @@ int main()
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
index 009c859ff..d73dc316d 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -32,4 +32,6 @@ int main()
         assert(atomic_flag_test_and_set(&f) == 0);
         assert(f.test_and_set() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp b/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
index 3a40328be..972a6e84b 100644
--- a/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
+++ b/test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -92,4 +92,6 @@ int main()
         assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0);
         assert(f.test_and_set() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/clear.pass.cpp b/test/std/atomics/atomics.flag/clear.pass.cpp
index cc877a477..33378e4bd 100644
--- a/test/std/atomics/atomics.flag/clear.pass.cpp
+++ b/test/std/atomics/atomics.flag/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f; // uninitialized
@@ -76,4 +76,6 @@ int main()
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/copy_assign.fail.cpp b/test/std/atomics/atomics.flag/copy_assign.fail.cpp
index 9fa766cad..aa5a24b9e 100644
--- a/test/std/atomics/atomics.flag/copy_assign.fail.cpp
+++ b/test/std/atomics/atomics.flag/copy_assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f0;
     std::atomic_flag f;
     f = f0;
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/copy_ctor.fail.cpp b/test/std/atomics/atomics.flag/copy_ctor.fail.cpp
index f167651c9..10deaf125 100644
--- a/test/std/atomics/atomics.flag/copy_ctor.fail.cpp
+++ b/test/std/atomics/atomics.flag/copy_ctor.fail.cpp
@@ -15,8 +15,10 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f0;
     std::atomic_flag f(f0);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp b/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
index 128778ab9..a453fab28 100644
--- a/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
+++ b/test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f0;
     volatile std::atomic_flag f;
     f = f0;
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/default.pass.cpp b/test/std/atomics/atomics.flag/default.pass.cpp
index 515e8108c..6a0d907fd 100644
--- a/test/std/atomics/atomics.flag/default.pass.cpp
+++ b/test/std/atomics/atomics.flag/default.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f;
     f.clear();
@@ -32,4 +32,6 @@ int main()
         assert(!zero.test_and_set());
         zero.~A();
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/init.pass.cpp b/test/std/atomics/atomics.flag/init.pass.cpp
index 8ca3bc9cc..a45784d80 100644
--- a/test/std/atomics/atomics.flag/init.pass.cpp
+++ b/test/std/atomics/atomics.flag/init.pass.cpp
@@ -18,8 +18,10 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f = ATOMIC_FLAG_INIT;
     assert(f.test_and_set() == 0);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.flag/test_and_set.pass.cpp b/test/std/atomics/atomics.flag/test_and_set.pass.cpp
index d567734d1..1a198c1be 100644
--- a/test/std/atomics/atomics.flag/test_and_set.pass.cpp
+++ b/test/std/atomics/atomics.flag/test_and_set.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -104,4 +104,6 @@ int main()
         assert(f.test_and_set(std::memory_order_seq_cst) == 0);
         assert(f.test_and_set(std::memory_order_seq_cst) == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.general/nothing_to_do.pass.cpp b/test/std/atomics/atomics.general/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/atomics/atomics.general/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.general/replace_failure_order.pass.cpp b/test/std/atomics/atomics.general/replace_failure_order.pass.cpp
index b246fc016..ee2384138 100644
--- a/test/std/atomics/atomics.general/replace_failure_order.pass.cpp
+++ b/test/std/atomics/atomics.general/replace_failure_order.pass.cpp
@@ -23,7 +23,7 @@
 
 #include <atomic>
 
-int main() {
+int main(int, char**) {
     std::atomic<int> i;
     volatile std::atomic<int> v;
     int exp = 0;
diff --git a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
index 5d1f3ba9a..d2ce1cefd 100644
--- a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
@@ -134,4 +134,4 @@ void run()
     static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
 }
 
-int main() { run(); }
+int main(int, char**) { run(); return 0; }
diff --git a/test/std/atomics/atomics.lockfree/lockfree.pass.cpp b/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
index cc448e662..b86893e0b 100644
--- a/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/lockfree.pass.cpp
@@ -24,7 +24,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(ATOMIC_BOOL_LOCK_FREE == 0 ||
            ATOMIC_BOOL_LOCK_FREE == 1 ||
@@ -56,4 +56,6 @@ int main()
     assert(ATOMIC_POINTER_LOCK_FREE == 0 ||
            ATOMIC_POINTER_LOCK_FREE == 1 ||
            ATOMIC_POINTER_LOCK_FREE == 2);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.order/kill_dependency.pass.cpp b/test/std/atomics/atomics.order/kill_dependency.pass.cpp
index 144bf5059..998b0cef3 100644
--- a/test/std/atomics/atomics.order/kill_dependency.pass.cpp
+++ b/test/std/atomics/atomics.order/kill_dependency.pass.cpp
@@ -15,8 +15,10 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::kill_dependency(5) == 5);
     assert(std::kill_dependency(-5.5) == -5.5);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.order/memory_order.pass.cpp b/test/std/atomics/atomics.order/memory_order.pass.cpp
index 69a46eac3..973f58583 100644
--- a/test/std/atomics/atomics.order/memory_order.pass.cpp
+++ b/test/std/atomics/atomics.order/memory_order.pass.cpp
@@ -19,7 +19,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::memory_order_relaxed == 0);
     assert(std::memory_order_consume == 1);
@@ -29,4 +29,6 @@ int main()
     assert(std::memory_order_seq_cst == 5);
     std::memory_order o = std::memory_order_seq_cst;
     assert(o == 5);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp b/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.generic/address.pass.cpp b/test/std/atomics/atomics.types.generic/address.pass.cpp
index 98c8d4f24..598889736 100644
--- a/test/std/atomics/atomics.types.generic/address.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/address.pass.cpp
@@ -136,7 +136,9 @@ void test()
     do_test<volatile A, T>();
 }
 
-int main()
+int main(int, char**)
 {
     test<std::atomic<int*>, int*>();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.generic/bool.pass.cpp b/test/std/atomics/atomics.types.generic/bool.pass.cpp
index 33901ce9b..154d0bfe6 100644
--- a/test/std/atomics/atomics.types.generic/bool.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/bool.pass.cpp
@@ -58,7 +58,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         volatile std::atomic<bool> obj(true);
@@ -232,4 +232,6 @@ int main()
         assert(zero == false);
         zero.~A();
     }
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp b/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
index 0c76e7b0f..a0648ff9c 100644
--- a/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
@@ -39,7 +39,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::atomic<  std::int_least8_t>,   std::atomic_int_least8_t>::value), "");
     static_assert((std::is_same<std::atomic< std::uint_least8_t>,  std::atomic_uint_least8_t>::value), "");
@@ -65,4 +65,6 @@ int main()
     static_assert((std::is_same<std::atomic<std::ptrdiff_t>, std::atomic_ptrdiff_t>::value), "");
     static_assert((std::is_same<std::atomic< std::intmax_t>,  std::atomic_intmax_t>::value), "");
     static_assert((std::is_same<std::atomic<std::uintmax_t>, std::atomic_uintmax_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.generic/integral.pass.cpp b/test/std/atomics/atomics.types.generic/integral.pass.cpp
index e59bee43c..62ef06bcc 100644
--- a/test/std/atomics/atomics.types.generic/integral.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral.pass.cpp
@@ -167,7 +167,7 @@ void test()
 }
 
 
-int main()
+int main(int, char**)
 {
     test<std::atomic_char, char>();
     test<std::atomic_schar, signed char>();
@@ -220,4 +220,6 @@ int main()
     test<volatile std::atomic_uint32_t, uint32_t>();
     test<volatile std::atomic_int64_t,   int64_t>();
     test<volatile std::atomic_uint64_t, uint64_t>();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp b/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
index d63043b84..faa682b8c 100644
--- a/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
@@ -40,7 +40,7 @@
 #include <atomic>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::atomic<char>, std::atomic_char>::value), "");
     static_assert((std::is_same<std::atomic<signed char>, std::atomic_schar>::value), "");
@@ -71,4 +71,6 @@ int main()
     static_assert((std::is_same<std::atomic<uint32_t>,  std::atomic_uint32_t>::value), "");
     static_assert((std::is_same<std::atomic<int64_t>,   std::atomic_int64_t>::value), "");
     static_assert((std::is_same<std::atomic<uint64_t>,  std::atomic_uint64_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp b/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
index 6ea65495c..3ec8ed25c 100644
--- a/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
+++ b/test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
@@ -63,7 +63,9 @@ void test ( T t ) {
     std::atomic<T> t0(t);
 }
 
-int main()
+int main(int, char**)
 {
     test(NotTriviallyCopyable(42));
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp b/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
index 03c68de86..229761eb3 100644
--- a/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
@@ -68,9 +68,11 @@ void test ( T t ) {
     std::atomic<T> t0(t);
     }
 
-int main()
+int main(int, char**)
 {
     test(TriviallyCopyable(42));
     test(std::this_thread::get_id());
     test(std::chrono::nanoseconds(2));
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
index 8d96adeea..041845d5b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
@@ -55,7 +55,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
index b557817d6..99a850886 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -62,7 +62,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
index 53f4174ec..a2a9e205d 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
@@ -56,7 +56,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
index 7edfb91cd..2ad17f1cb 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -64,7 +64,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
index 43e6b804b..d13238e65 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
@@ -41,7 +41,9 @@ struct TestFn {
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
index 14e8ed1af..2acbcb20f 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
@@ -43,7 +43,9 @@ struct TestFn {
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
index deb68b170..f84a48983 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
@@ -74,9 +74,11 @@ void testp()
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
index a75acb341..fbdf3fffc 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
@@ -79,9 +79,11 @@ testp()
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
index f80d7a82c..dfaaaa3e5 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
@@ -44,7 +44,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
index 77a89dc79..d31245a84 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
@@ -46,7 +46,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
index 19c321539..741dca00e 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
@@ -44,7 +44,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
index af0a7e8ab..e56e946f4 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
@@ -46,7 +46,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
index 8298327a9..13fde4ad6 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
@@ -74,9 +74,11 @@ void testp()
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
index b7447ad7a..af97bcc60 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
@@ -79,9 +79,11 @@ void testp()
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
index 5eaf5039f..0e6f99f36 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
@@ -44,7 +44,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
index 83ac8dbe5..ece156945 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
@@ -46,7 +46,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
index bcb729469..0e5b920f9 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
@@ -38,7 +38,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
index e8352cd8e..bfa24dae5 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
@@ -40,8 +40,10 @@ struct A
     char _[4];
 };
 
-int main()
+int main(int, char**)
 {
     TestFn<A>()();
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
index 9431331d6..b775c5467 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
@@ -38,7 +38,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
index d6cf08605..0384baa5a 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
@@ -38,7 +38,9 @@ struct TestFn {
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
index 6f91792fb..0fb3bc7dd 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
@@ -38,7 +38,9 @@ struct TestFn {
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
index c63c5cc1b..11aa295de 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
@@ -38,7 +38,9 @@ struct TestFn {
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
index 9111d8bd0..1588af327 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
@@ -17,8 +17,10 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic<int> v = ATOMIC_VAR_INIT(5);
     assert(v == 5);
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
index 563a05337..d692e931b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
@@ -56,8 +56,10 @@ struct TestFunc {
 };
 
 
-int main()
+int main(int, char**)
 {
     TestFunc<UserType>()();
     TestEachIntegralType<TestFunc>()();
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp b/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
+++ b/test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/associative/iterator_types.pass.cpp b/test/std/containers/associative/iterator_types.pass.cpp
index f18fa2b4f..1b8556fb5 100644
--- a/test/std/containers/associative/iterator_types.pass.cpp
+++ b/test/std/containers/associative/iterator_types.pass.cpp
@@ -50,7 +50,7 @@ void testSet() {
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef std::map<int, int> Map;
     typedef std::pair<const int, int> ValueTp;
@@ -127,4 +127,6 @@ int main() {
     testSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp b/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
index ff0be2084..030fdaf39 100644
--- a/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
+++ b/test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
@@ -24,7 +24,9 @@ struct F {
     F() { m[42] = &dummy; }
 };
 
-int main() {
+int main(int, char**) {
     F f;
     f = F();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/allocator_mismatch.fail.cpp b/test/std/containers/associative/map/allocator_mismatch.fail.cpp
index 08f5ee94f..faec5aa40 100644
--- a/test/std/containers/associative/map/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/map/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <map>
 
-int main()
+int main(int, char**)
 {
     std::map<int, int, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/compare.pass.cpp b/test/std/containers/associative/map/compare.pass.cpp
index fedc9d2b3..84de27184 100644
--- a/test/std/containers/associative/map/compare.pass.cpp
+++ b/test/std/containers/associative/map/compare.pass.cpp
@@ -24,7 +24,7 @@ struct Key {
   bool operator< (const Key&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::map<Key, int> MapT;
     typedef MapT::iterator Iter;
@@ -48,4 +48,6 @@ int main()
         assert(!result2.second);
         assert(map[Key(0)] == 42);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/gcc_workaround.pass.cpp b/test/std/containers/associative/map/gcc_workaround.pass.cpp
index 622449fac..9e05b66a5 100644
--- a/test/std/containers/associative/map/gcc_workaround.pass.cpp
+++ b/test/std/containers/associative/map/gcc_workaround.pass.cpp
@@ -15,7 +15,4 @@ std::map<int,int>::iterator it;
 using std::set;
 using std::multiset;
 
-int main(void)
-{
-       return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/test/std/containers/associative/map/incomplete_type.pass.cpp b/test/std/containers/associative/map/incomplete_type.pass.cpp
index 1bc320e9c..a45c50c32 100644
--- a/test/std/containers/associative/map/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/map/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/at.pass.cpp b/test/std/containers/associative/map/map.access/at.pass.cpp
index 475dd641c..c13c6a64a 100644
--- a/test/std/containers/associative/map/map.access/at.pass.cpp
+++ b/test/std/containers/associative/map/map.access/at.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -160,4 +160,6 @@ int main()
         assert(m.size() == 7);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/empty.fail.cpp b/test/std/containers/associative/map/map.access/empty.fail.cpp
index 0305fdb56..61c4e757b 100644
--- a/test/std/containers/associative/map/map.access/empty.fail.cpp
+++ b/test/std/containers/associative/map/map.access/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::map<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/empty.pass.cpp b/test/std/containers/associative/map/map.access/empty.pass.cpp
index 1317ee310..cff13df7a 100644
--- a/test/std/containers/associative/map/map.access/empty.pass.cpp
+++ b/test/std/containers/associative/map/map.access/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double> M;
@@ -39,4 +39,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/index_key.pass.cpp b/test/std/containers/associative/map/map.access/index_key.pass.cpp
index 1d842205a..8df052e01 100644
--- a/test/std/containers/associative/map/map.access/index_key.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_key.pass.cpp
@@ -23,7 +23,7 @@
 #include "container_test_types.h"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -139,4 +139,6 @@ int main()
     assert(m.size() == 8);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp b/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
index 523d4e6d8..7effa0c64 100644
--- a/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
@@ -23,7 +23,7 @@
 #include "min_allocator.h"
 #include "container_test_types.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::map<MoveOnly, double> m;
@@ -76,4 +76,6 @@ int main()
             }
         }
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/index_tuple.pass.cpp b/test/std/containers/associative/map/map.access/index_tuple.pass.cpp
index 5f39bece0..bc99f6ef8 100644
--- a/test/std/containers/associative/map/map.access/index_tuple.pass.cpp
+++ b/test/std/containers/associative/map/map.access/index_tuple.pass.cpp
@@ -22,9 +22,11 @@
 #include <tuple>
 
 
-int main()
+int main(int, char**)
 {
     using namespace std;
     map<tuple<int,int>, size_t> m;
     m[make_tuple(2,3)]=7;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/iterator.pass.cpp b/test/std/containers/associative/map/map.access/iterator.pass.cpp
index c1c503733..39b573a13 100644
--- a/test/std/containers/associative/map/map.access/iterator.pass.cpp
+++ b/test/std/containers/associative/map/map.access/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -225,4 +225,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/max_size.pass.cpp b/test/std/containers/associative/map/map.access/max_size.pass.cpp
index 1bb873f4b..b38cf1146 100644
--- a/test/std/containers/associative/map/map.access/max_size.pass.cpp
+++ b/test/std/containers/associative/map/map.access/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -47,4 +47,6 @@ int main()
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.access/size.pass.cpp b/test/std/containers/associative/map/map.access/size.pass.cpp
index 4408dc54e..bb4b14e02 100644
--- a/test/std/containers/associative/map/map.access/size.pass.cpp
+++ b/test/std/containers/associative/map/map.access/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double> M;
@@ -55,4 +55,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/alloc.pass.cpp b/test/std/containers/associative/map/map.cons/alloc.pass.cpp
index 04000bec9..5bb9abc88 100644
--- a/test/std/containers/associative/map/map.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::less<int> C;
@@ -46,4 +46,6 @@ int main()
     assert(m.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
index 664d6cf08..612838ef6 100644
--- a/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -69,4 +69,6 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/compare.pass.cpp b/test/std/containers/associative/map/map.cons/compare.pass.cpp
index 2fb00ebde..40a8e38ae 100644
--- a/test/std/containers/associative/map/map.cons/compare.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/compare.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -38,4 +38,6 @@ int main()
     assert(m.key_comp() == C(3));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
index d4de57163..71bc32295 100644
--- a/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -50,4 +50,6 @@ int main()
     assert(m.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
index 1e75326de..3c714de40 100644
--- a/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::map<int, int, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/copy.pass.cpp b/test/std/containers/associative/map/map.cons/copy.pass.cpp
index 0e7266d59..8eec27b3e 100644
--- a/test/std/containers/associative/map/map.cons/copy.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -126,4 +126,6 @@ int main()
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
index 0e01b3674..d25504382 100644
--- a/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -125,4 +125,6 @@ int main()
     assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp b/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
index e63cbe951..a902e0560 100644
--- a/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
@@ -108,7 +108,7 @@ bool balanced_allocs() {
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -337,4 +337,6 @@ int main()
     }
     assert(balanced_allocs());
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/default.pass.cpp b/test/std/containers/associative/map/map.cons/default.pass.cpp
index 3a2b7fb48..5d3fcaee1 100644
--- a/test/std/containers/associative/map/map.cons/default.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::map<int, double> m;
@@ -50,4 +50,6 @@ int main()
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
index 61f87b3c1..2e4b4242d 100644
--- a/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
 #if defined(_LIBCPP_VERSION)
@@ -54,4 +54,6 @@ int main()
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp b/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
index fb01aacf6..af8fbe79f 100644
--- a/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
@@ -23,6 +23,8 @@ struct X
     std::map<int, X>::const_reverse_iterator cri;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
index fb07754c6..2a2e89bf4 100644
--- a/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_comp
     bool operator()(const T&, const T&) const noexcept { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -48,4 +48,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
index b7f916c11..1303f7ef2 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -61,4 +61,6 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
index 887597768..9b6a47ac3 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -63,4 +63,6 @@ int main()
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
index 5288d64f0..0da3115f7 100644
--- a/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -116,4 +116,6 @@ int main()
     assert(m.key_comp() == C(3));
     assert(m.get_allocator() == a);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
index 2a17bffb5..243800cfd 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -64,4 +64,6 @@ int main()
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
index 416725783..12a079ea0 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -69,4 +69,6 @@ int main()
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
index c8861573a..56396799d 100644
--- a/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -119,4 +119,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/move.pass.cpp b/test/std/containers/associative/map/map.cons/move.pass.cpp
index f2f8dd8a9..ecf8c9dab 100644
--- a/test/std/containers/associative/map/map.cons/move.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -114,4 +114,6 @@ int main()
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
index cec925356..aa87e9ff0 100644
--- a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -268,4 +268,6 @@ int main()
         assert(m3.key_comp() == C(5));
         LIBCPP_ASSERT(m1.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/move_assign.pass.cpp b/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
index be06d49c9..758d0f83f 100644
--- a/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -184,4 +184,6 @@ int main()
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
index 42bc980b7..fcb926071 100644
--- a/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -54,4 +54,6 @@ int main()
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp b/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
index dd61439ca..44b2b7e22 100644
--- a/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     typedef std::pair<const MoveOnly, MoveOnly> V;
@@ -52,4 +52,6 @@ int main()
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp b/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
index af7accdff..88a958368 100644
--- a/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::map<int, int>>();
     test<std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -74,5 +74,7 @@ int main()
 
     test<std::map<long, short>>();
     test<std::map<short, double>>();
+
+  return 0;
 }
 
diff --git a/test/std/containers/associative/map/map.modifiers/clear.pass.cpp b/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
index 895a8115a..5c6d00e9f 100644
--- a/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -62,4 +62,6 @@ int main()
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp b/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
index 8680ab821..382e5c8ba 100644
--- a/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, DefaultOnly> M;
@@ -159,4 +159,6 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp b/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
index 1c649093f..516d88054 100644
--- a/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, DefaultOnly> M;
@@ -154,4 +154,6 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
index 57de16478..0f23ef638 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
@@ -25,7 +25,7 @@ struct TemplateConstructor
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -255,4 +255,6 @@ int main()
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
index 875fab538..71fa96ce1 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -153,4 +153,6 @@ int main()
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp b/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
index 23fae9a60..da96499b0 100644
--- a/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -271,4 +271,6 @@ int main()
         assert(s == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp b/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
index 95ba2b711..f2b67c9ff 100644
--- a/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::map<int, int>;
@@ -63,4 +63,6 @@ int main()
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp b/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
index 70afd45ff..018e9acf8 100644
--- a/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::map<int, int> m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}};
@@ -72,4 +72,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
index 9adb3d619..f3e840021 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -21,10 +21,12 @@
 #include "container_test_types.h"
 #include "../../../map_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMapInsert<TCT::map<> >();
   testMapInsertHint<TCT::map<> >();
   testMapEmplace<TCT::map<> >();
   testMapEmplaceHint<TCT::map<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
index 50801f721..079b0eaca 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
@@ -59,7 +59,7 @@ void do_insert_cv_test()
     assert(r.first->second == 3.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_cv_test<std::map<int, double> >();
 #if TEST_STD_VER >= 11
@@ -68,4 +68,6 @@ int main()
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
index 124a40c33..ea6c13800 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -65,4 +65,6 @@ int main()
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
index f993bc202..a49a28c67 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
@@ -55,7 +55,7 @@ void do_insert_iter_cv_test()
     assert(r->second == 3.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_iter_cv_test<std::map<int, double> >();
 #if TEST_STD_VER >= 11
@@ -64,4 +64,6 @@ int main()
         do_insert_iter_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
index 6315bc40e..a6a776336 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -73,4 +73,6 @@ int main()
         assert(next(m.begin(), 2)->second == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
index 45665a411..8cbbebe5d 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
@@ -53,7 +53,7 @@ void do_insert_iter_rv_test()
     assert(r->first == 3);
     assert(r->second == 3);
 }
-int main()
+int main(int, char**)
 {
     do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
     do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
@@ -94,4 +94,6 @@ int main()
         assert(r->second == 3);
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
index 3ad5f46b4..f3f166260 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
@@ -75,10 +75,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::map<int, int> m;
     test(m);
     std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
index 41d264f3f..084f7ee2c 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
@@ -54,10 +54,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::map<int, int> m;
     test(m);
     std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
index 69caa8434..bd9625a09 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
@@ -56,7 +56,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
         typedef std::map<int, Moveable> M;
@@ -181,4 +181,6 @@ int main()
         assert(r->first.get()  == 3);  // key
         assert(r->second.get() == 5);  // value
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp b/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
index 439adfde2..e6fb13ee3 100644
--- a/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
@@ -59,7 +59,7 @@ void do_insert_rv_test()
     assert(r.first->second == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
     do_insert_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
@@ -103,4 +103,6 @@ int main()
         assert(r.first->first == 3);
         assert(r.first->second == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/merge.pass.cpp b/test/std/containers/associative/map/map.modifiers/merge.pass.cpp
index 1cef30944..ae943df6a 100644
--- a/test/std/containers/associative/map/map.modifiers/merge.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_comparator
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::map<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -146,4 +146,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp b/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
index 43d5c3cac..fe9484a3c 100644
--- a/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
+++ b/test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
@@ -54,7 +54,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     { // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
         typedef std::map<int, Moveable> M;
@@ -178,4 +178,6 @@ int main()
         assert(r->first.get()  == 3); // key
         assert(r->second.get() == 4); // value
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/count.pass.cpp b/test/std/containers/associative/map/map.ops/count.pass.cpp
index 9ac980670..8abae288b 100644
--- a/test/std/containers/associative/map/map.ops/count.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count.pass.cpp
@@ -20,7 +20,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -190,4 +190,6 @@ int main()
     assert(r == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/count0.pass.cpp b/test/std/containers/associative/map/map.ops/count0.pass.cpp
index eeaa41a00..cce0444fd 100644
--- a/test/std/containers/associative/map/map.ops/count0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -35,4 +35,6 @@ int main()
     typedef std::map<int, double, transparent_less_not_referenceable> M;
     assert(M().count(C2Int{5}) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/count1.fail.cpp b/test/std/containers/associative/map/map.ops/count1.fail.cpp
index 049ee980a..42dc59c27 100644
--- a/test/std/containers/associative/map/map.ops/count1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/map/map.ops/count2.fail.cpp b/test/std/containers/associative/map/map.ops/count2.fail.cpp
index 6b4c07572..1fe6b927d 100644
--- a/test/std/containers/associative/map/map.ops/count2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/map/map.ops/count3.fail.cpp b/test/std/containers/associative/map/map.ops/count3.fail.cpp
index 525c57cef..3fd930eb2 100644
--- a/test/std/containers/associative/map/map.ops/count3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp b/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
index fb33d3b0a..fa6490242 100644
--- a/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
@@ -40,10 +40,12 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::map<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 2}, 2}, {{1, 3}, 3}, {{1, 4}, 4}, {{2, 2}, 5}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/equal_range.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
index 3c0c16fb5..c46e52c71 100644
--- a/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -487,4 +487,6 @@ int main()
     assert(r.second == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
index 27dac20ae..22f067a2a 100644
--- a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -41,4 +41,6 @@ int main()
     P result = example.equal_range(C2Int{5});
     assert(result.first == result.second);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
index 629541c1d..f8ccfc3d8 100644
--- a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
index db3fe9eea..dcde9fc2e 100644
--- a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
index bdd1ae681..f773c482c 100644
--- a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
index 4387967eb..442213561 100644
--- a/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
@@ -43,7 +43,7 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::map<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 2}, 2}, {{1, 3}, 3}, {{1, 4}, 4}, {{2, 2}, 5}};
 
@@ -56,4 +56,6 @@ int main() {
   }
 
   assert(nels == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/find.pass.cpp b/test/std/containers/associative/map/map.ops/find.pass.cpp
index ca01e839c..bcf498ecf 100644
--- a/test/std/containers/associative/map/map.ops/find.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/find.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -257,4 +257,6 @@ int main()
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/find0.pass.cpp b/test/std/containers/associative/map/map.ops/find0.pass.cpp
index a684738df..affc61efb 100644
--- a/test/std/containers/associative/map/map.ops/find0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/find0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -37,4 +37,6 @@ int main()
     M example;
     assert(example.find(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/find1.fail.cpp b/test/std/containers/associative/map/map.ops/find1.fail.cpp
index 1cad78a39..6bd1a95ab 100644
--- a/test/std/containers/associative/map/map.ops/find1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/map/map.ops/find2.fail.cpp b/test/std/containers/associative/map/map.ops/find2.fail.cpp
index cd8858316..7af1c0eb8 100644
--- a/test/std/containers/associative/map/map.ops/find2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/map/map.ops/find3.fail.cpp b/test/std/containers/associative/map/map.ops/find3.fail.cpp
index 62a4a648f..32164fd3a 100644
--- a/test/std/containers/associative/map/map.ops/find3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp b/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
index 3572b08f7..5b1c925a6 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -369,4 +369,6 @@ int main()
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
index 50752e8da..a92790f2b 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -37,4 +37,6 @@ int main()
     M example;
     assert(example.lower_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
index 095e1b3b3..efdc762e8 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
index 455e8fa99..362b223ff 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
index 8c9ac1d65..cc8bdf92a 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp b/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
index 58ccd7f43..c7fdd879a 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -332,4 +332,6 @@ int main()
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
index 723cdc6df..8f58df61b 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -37,4 +37,6 @@ int main()
     M example;
     assert(example.upper_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
index fa4afc987..8ed0eed59 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
index 5be763366..d08b6c0f0 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
index 773f114f9..df7cd2269 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/map/map.special/member_swap.pass.cpp b/test/std/containers/associative/map/map.special/member_swap.pass.cpp
index 4f985bae3..a41e43f7a 100644
--- a/test/std/containers/associative/map/map.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/map/map.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -172,4 +172,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp b/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
index aea80f9c3..811acc457 100644
--- a/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -277,4 +277,6 @@ int main()
         assert(m2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp b/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
index 346057415..4e1497f7a 100644
--- a/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -138,4 +138,6 @@ int main()
 #endif // _LIBCPP_VERSION
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/associative/map/types.pass.cpp b/test/std/containers/associative/map/types.pass.cpp
index f9f7abc28..35fc06743 100644
--- a/test/std/containers/associative/map/types.pass.cpp
+++ b/test/std/containers/associative/map/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double> C;
@@ -66,4 +66,6 @@ int main()
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp b/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
index f59df265a..47dd64ebc 100644
--- a/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <map>
 
-int main()
+int main(int, char**)
 {
     std::multimap<int, int, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/empty.fail.cpp b/test/std/containers/associative/multimap/empty.fail.cpp
index 91fc1026f..bc305b9cc 100644
--- a/test/std/containers/associative/multimap/empty.fail.cpp
+++ b/test/std/containers/associative/multimap/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::multimap<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/empty.pass.cpp b/test/std/containers/associative/multimap/empty.pass.cpp
index a83e2265c..12866a0f2 100644
--- a/test/std/containers/associative/multimap/empty.pass.cpp
+++ b/test/std/containers/associative/multimap/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> M;
@@ -39,4 +39,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/incomplete_type.pass.cpp b/test/std/containers/associative/multimap/incomplete_type.pass.cpp
index 5f83dce46..0132ce9fe 100644
--- a/test/std/containers/associative/multimap/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/multimap/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/iterator.pass.cpp b/test/std/containers/associative/multimap/iterator.pass.cpp
index f27bce16d..0a6153118 100644
--- a/test/std/containers/associative/multimap/iterator.pass.cpp
+++ b/test/std/containers/associative/multimap/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -229,4 +229,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/max_size.pass.cpp b/test/std/containers/associative/multimap/max_size.pass.cpp
index 106bb667c..a4537c3d1 100644
--- a/test/std/containers/associative/multimap/max_size.pass.cpp
+++ b/test/std/containers/associative/multimap/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -47,4 +47,6 @@ int main()
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
index e8c35d5a8..6e7e3aa09 100644
--- a/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::less<int> C;
@@ -46,4 +46,6 @@ int main()
     assert(m.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
index 47e4e71a3..037406251 100644
--- a/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -79,4 +79,6 @@ int main()
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
index 5b83bb0be..54bf998ec 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -38,4 +38,6 @@ int main()
     assert(m.key_comp() == C(3));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
index 1f11066f8..44942036c 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -50,4 +50,6 @@ int main()
     assert(m.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
index 19276a0ee..23fe479f5 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::multimap<int, int, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
index c691a1965..d3b064256 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -99,4 +99,6 @@ int main()
         assert(mo.key_comp() == C(5));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
index 3c549d6ae..7144a25f9 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -98,4 +98,6 @@ int main()
     assert(mo.key_comp() == C(5));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
index d49290868..6816a5ee4 100644
--- a/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -121,4 +121,6 @@ int main()
         assert(mo.key_comp() == C(5));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
index 6c59b603b..6b3308843 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::multimap<int, double> m;
@@ -50,4 +50,6 @@ int main()
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
index d55adedc9..e5a28601e 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
 #if defined(_LIBCPP_VERSION)
@@ -54,4 +54,6 @@ int main()
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
index 8d960dbe3..b51b6b63b 100644
--- a/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
@@ -23,6 +23,8 @@ struct X
     std::multimap<int, X>::const_reverse_iterator cri;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
index 01cdff8c3..100746789 100644
--- a/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -48,4 +48,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
index bd26b397c..2642ba6a8 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -77,4 +77,6 @@ int main()
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
index a3f29e607..c8e2d293f 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > Cmp;
@@ -85,4 +85,6 @@ int main()
     assert(*++i == V(3, 2));
     assert(m.key_comp() == Cmp(4));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
index 572a3cfb0..592dec997 100644
--- a/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > Cmp;
@@ -155,4 +155,6 @@ int main()
     assert(m.key_comp() == Cmp(4));
     assert(m.get_allocator() == A{});
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
index 0ea352404..4d92b3d0b 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -109,4 +109,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
index aa114a25a..d10904a4d 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -82,4 +82,6 @@ int main()
     assert(*next(m.begin(), 8) == V(3, 2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
index 7d02c7539..a71c757ff 100644
--- a/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -118,4 +118,6 @@ int main()
     assert(*next(m.begin(), 8) == V(3, 2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
index 324e0a140..cef685774 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -126,4 +126,6 @@ int main()
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
index 3342a4eda..712afbeaa 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -268,4 +268,6 @@ int main()
         assert(m3.key_comp() == C(5));
         LIBCPP_ASSERT(m1.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
index c1f8e7e5a..386c11ecb 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -184,4 +184,6 @@ int main()
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
index 41ea65853..2afcc5e58 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -54,4 +54,6 @@ int main()
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
index b1c148a9f..377167484 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     typedef std::pair<const MoveOnly, MoveOnly> V;
@@ -52,4 +52,6 @@ int main()
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp b/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
index dc448f58d..15893f77b 100644
--- a/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
@@ -77,7 +77,7 @@ void test()
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::multimap<int, int>>();
     test<std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -85,4 +85,6 @@ int main()
 
     test<std::multimap<long, short>>();
     test<std::multimap<short, double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
index 0cb5cb29b..d05a13b5f 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -62,4 +62,6 @@ int main()
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
index 2780d3a53..76d9b1718 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, DefaultOnly> M;
@@ -144,4 +144,6 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
index 49ee3069b..3ad09f38a 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, DefaultOnly> M;
@@ -154,4 +154,6 @@ int main()
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
index 62ab3f5fd..a0f70d640 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
@@ -25,7 +25,7 @@ struct TemplateConstructor
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -297,4 +297,6 @@ int main()
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
index f561d149b..deef1a146 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -153,4 +153,6 @@ int main()
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
index f881c77c2..0ab1d4cb8 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -149,4 +149,6 @@ int main()
         assert(i == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
index a0992d751..fe3c78832 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::multimap<int, int>;
@@ -63,4 +63,6 @@ int main()
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
index 687043a4c..e2a80dab2 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::multimap<int, int> m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}};
@@ -72,4 +72,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
index 008770cbf..9a791af57 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -20,8 +20,10 @@
 #include "../../../map_allocator_requirement_test_templates.h"
 
 
-int main()
+int main(int, char**)
 {
   testMultimapInsert<TCT::multimap<> >();
   testMultimapInsertHint<TCT::multimap<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
index 8c4e51b24..b83034448 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
@@ -53,7 +53,7 @@ void do_insert_test() {
     assert(r->second == 3.5);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> Container;
@@ -65,4 +65,6 @@ int main()
         do_insert_test<Container>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
index 2da3e7d49..33104ca88 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -85,4 +85,6 @@ int main()
     assert(*++i == V(3, 2));
     assert(*++i == V(3, 1.5));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
index 946193446..fb3283f83 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
@@ -54,7 +54,7 @@ void do_insert_hint_test()
     assert(r->second == 4.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_test<std::multimap<int, double> >();
 #if TEST_STD_VER >= 11
@@ -63,4 +63,6 @@ int main()
         do_insert_hint_test<M>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
index f7a11f86c..9533a6289 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -97,4 +97,6 @@ int main()
         assert(next(m.begin(), 8)->second == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
index 0912136f1..5eea856a0 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
@@ -54,7 +54,7 @@ void do_insert_rv_test()
     assert(r->second == 2);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_rv_test<std::multimap<int, MoveOnly>, std::pair<int, MoveOnly> >();
     do_insert_rv_test<std::multimap<int, MoveOnly>, std::pair<const int, MoveOnly> >();
@@ -95,4 +95,6 @@ int main()
         assert(r->first == 3);
         assert(r->second == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
index 71122d3a3..7fb62a7c1 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
@@ -68,10 +68,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multimap<int, int> m;
     test(m);
     std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
index edc7d2bd3..847a70136 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
@@ -54,10 +54,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multimap<int, int> m;
     test(m);
     std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
index 041ce97a6..05393345c 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
@@ -54,7 +54,7 @@ void do_insert_rv_test()
     assert(r->second == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_rv_test<std::multimap<int, MoveOnly>>();
     {
@@ -89,4 +89,6 @@ int main()
         assert(r->first == 3);
         assert(r->second == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp b/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
index 449d5d92d..78b24323d 100644
--- a/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_comparator
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::multimap<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -146,4 +146,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
index 7bdb4d200..053a771ba 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
@@ -20,7 +20,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -172,4 +172,6 @@ int main()
     assert(r == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
index f725d16f8..75f9f2228 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -35,4 +35,6 @@ int main()
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
     assert(M().count(C2Int{5}) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
index 28842553b..594a424fa 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
index 5f06d3226..1f98052b7 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_private> M;
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
index 2f3aa4dcb..3304d9f06 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
index 0483276f8..e6348cbef 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
@@ -40,10 +40,12 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multimap<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 1}, 2}, {{1, 1}, 3}, {{1, 1}, 4}, {{2, 2}, 5}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
index 47380d881..3d4997f48 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -283,4 +283,6 @@ int main()
     assert(r.second == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
index 48002b381..c01395f0a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -41,4 +41,6 @@ int main()
     P result = example.equal_range(C2Int{5});
     assert(result.first == result.second);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
index ea7941c71..b826f018f 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
index a6fc925a8..a533a7144 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
index 8b5e77242..2a26a5849 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
index 34326a453..95af97cee 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
@@ -43,7 +43,7 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multimap<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 1}, 2}, {{1, 1}, 3}, {{1, 1}, 4}, {{2, 2}, 5}};
 
@@ -56,4 +56,6 @@ int main() {
   }
 
   assert(nels == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
index 006f98b96..e526d9a32 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -219,4 +219,6 @@ int main()
     assert(r == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
index 2516b16e7..39a8735bc 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -37,4 +37,6 @@ int main()
     M example;
     assert(example.find(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
index 754df859a..a22d1b5a0 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
index 898fdbafb..cf2e4b498 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
index 68608e8d0..2be4062bb 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
index c94f99d49..77550b518 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -233,4 +233,6 @@ int main()
     }
 
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
index fd604d14e..1311c9c5a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -37,4 +37,6 @@ int main()
     M example;
     assert(example.lower_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
index 510421a8a..0279f54bf 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
index afcf3285a..2282003f4 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
index 3c7e27676..f5751647a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
index 5a0d7c3ce..762387d80 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -232,4 +232,6 @@ int main()
     }
 
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
index 5f257ece9..28c9ff75a 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -37,4 +37,6 @@ int main()
     M example;
     assert(example.upper_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
index 33775d238..39ecc3cc4 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
index c2be3e7eb..f51a199c1 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
index 5c1d2a77b..68d057100 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
diff --git a/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp b/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
index 09740b3f3..fe8399713 100644
--- a/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -172,4 +172,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp b/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
index b776766dd..3e75991ee 100644
--- a/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -277,4 +277,6 @@ int main()
         assert(m2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp b/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
index 7c42ff170..9d5dab06c 100644
--- a/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -137,4 +137,6 @@ int main()
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/scary.pass.cpp b/test/std/containers/associative/multimap/scary.pass.cpp
index 2032bfc96..faf839b8e 100644
--- a/test/std/containers/associative/multimap/scary.pass.cpp
+++ b/test/std/containers/associative/multimap/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <map>
 
-int main()
+int main(int, char**)
 {
     typedef std::map<int, int> M1;
     typedef std::multimap<int, int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/size.pass.cpp b/test/std/containers/associative/multimap/size.pass.cpp
index b608b99e9..df18f7b58 100644
--- a/test/std/containers/associative/multimap/size.pass.cpp
+++ b/test/std/containers/associative/multimap/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> M;
@@ -55,4 +55,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multimap/types.pass.cpp b/test/std/containers/associative/multimap/types.pass.cpp
index 7c91ab3bd..67723f5cd 100644
--- a/test/std/containers/associative/multimap/types.pass.cpp
+++ b/test/std/containers/associative/multimap/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -66,4 +66,6 @@ int main()
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp b/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
index ffa0e9640..86e1b307a 100644
--- a/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <set>
 
-int main()
+int main(int, char**)
 {
     std::multiset<int, std::less<int>, std::allocator<long> > ms;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/clear.pass.cpp b/test/std/containers/associative/multiset/clear.pass.cpp
index b5ad9e4f3..93f9fef2c 100644
--- a/test/std/containers/associative/multiset/clear.pass.cpp
+++ b/test/std/containers/associative/multiset/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -62,4 +62,6 @@ int main()
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/count.pass.cpp b/test/std/containers/associative/multiset/count.pass.cpp
index 61d64adb6..3ac6f9423 100644
--- a/test/std/containers/associative/multiset/count.pass.cpp
+++ b/test/std/containers/associative/multiset/count.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -157,4 +157,6 @@ int main()
     assert(r == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/count_transparent.pass.cpp b/test/std/containers/associative/multiset/count_transparent.pass.cpp
index e26744a75..1239286f7 100644
--- a/test/std/containers/associative/multiset/count_transparent.pass.cpp
+++ b/test/std/containers/associative/multiset/count_transparent.pass.cpp
@@ -42,9 +42,11 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multiset<std::pair<int, int>, Comp> s{{2, 1}, {1, 1}, {1, 1}, {1, 1}, {2, 2}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/emplace.pass.cpp b/test/std/containers/associative/multiset/emplace.pass.cpp
index 8e7b6946c..1cabd12fc 100644
--- a/test/std/containers/associative/multiset/emplace.pass.cpp
+++ b/test/std/containers/associative/multiset/emplace.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<DefaultOnly> M;
@@ -77,4 +77,6 @@ int main()
         assert(m.size() == 1);
         assert(*r == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/emplace_hint.pass.cpp b/test/std/containers/associative/multiset/emplace_hint.pass.cpp
index d8723d8d9..17db3b4b3 100644
--- a/test/std/containers/associative/multiset/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/multiset/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<DefaultOnly> M;
@@ -77,4 +77,6 @@ int main()
         assert(m.size() == 1);
         assert(*r == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/empty.fail.cpp b/test/std/containers/associative/multiset/empty.fail.cpp
index 29c31a089..4467b4870 100644
--- a/test/std/containers/associative/multiset/empty.fail.cpp
+++ b/test/std/containers/associative/multiset/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::multiset<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/empty.pass.cpp b/test/std/containers/associative/multiset/empty.pass.cpp
index f0591d8e3..2ca20491f 100644
--- a/test/std/containers/associative/multiset/empty.pass.cpp
+++ b/test/std/containers/associative/multiset/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> M;
@@ -39,4 +39,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/equal_range.pass.cpp b/test/std/containers/associative/multiset/equal_range.pass.cpp
index 740ecc7f2..44c6c17ec 100644
--- a/test/std/containers/associative/multiset/equal_range.pass.cpp
+++ b/test/std/containers/associative/multiset/equal_range.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -260,4 +260,6 @@ int main()
     assert(r.second == next(m.begin(), 9));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp b/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
index 075aab1a3..d052cf169 100644
--- a/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
@@ -44,7 +44,7 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multiset<std::pair<int, int>, Comp> s{{2, 1}, {1, 1}, {1, 1}, {1, 1}, {2, 2}};
 
   auto er = s.equal_range(1);
@@ -56,4 +56,6 @@ int main() {
   }
 
   assert(nels == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/erase_iter.pass.cpp b/test/std/containers/associative/multiset/erase_iter.pass.cpp
index 506a0a7c2..bcedbf338 100644
--- a/test/std/containers/associative/multiset/erase_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_iter.pass.cpp
@@ -25,7 +25,7 @@ struct TemplateConstructor
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -199,4 +199,6 @@ int main()
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp b/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
index b1e2d143b..03c725285 100644
--- a/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -137,4 +137,6 @@ int main()
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/erase_key.pass.cpp b/test/std/containers/associative/multiset/erase_key.pass.cpp
index d2c3d17db..4b1db0529 100644
--- a/test/std/containers/associative/multiset/erase_key.pass.cpp
+++ b/test/std/containers/associative/multiset/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -125,4 +125,6 @@ int main()
         assert(i == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/extract_iterator.pass.cpp b/test/std/containers/associative/multiset/extract_iterator.pass.cpp
index f16208190..ef2a64ede 100644
--- a/test/std/containers/associative/multiset/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/multiset/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::multiset<int>;
@@ -56,4 +56,6 @@ int main()
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/extract_key.pass.cpp b/test/std/containers/associative/multiset/extract_key.pass.cpp
index 7fc0459ca..d95667def 100644
--- a/test/std/containers/associative/multiset/extract_key.pass.cpp
+++ b/test/std/containers/associative/multiset/extract_key.pass.cpp
@@ -43,7 +43,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::multiset<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/find.pass.cpp b/test/std/containers/associative/multiset/find.pass.cpp
index 44d8d051c..7a6584b2b 100644
--- a/test/std/containers/associative/multiset/find.pass.cpp
+++ b/test/std/containers/associative/multiset/find.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -237,4 +237,6 @@ int main()
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/incomplete_type.pass.cpp b/test/std/containers/associative/multiset/incomplete_type.pass.cpp
index 71166b2ec..a118a6230 100644
--- a/test/std/containers/associative/multiset/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/multiset/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_cv.pass.cpp b/test/std/containers/associative/multiset/insert_cv.pass.cpp
index 21fec2cd9..856d54da0 100644
--- a/test/std/containers/associative/multiset/insert_cv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_cv.pass.cpp
@@ -48,7 +48,7 @@ void do_insert_cv_test()
     assert(*r == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_cv_test<std::multiset<int> >();
 #if TEST_STD_VER >= 11
@@ -57,4 +57,6 @@ int main()
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
index 6b6c22f28..083dea739 100644
--- a/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
@@ -19,8 +19,10 @@
 #include "container_test_types.h"
 #include "../../set_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMultisetInsert<TCT::multiset<> >();
   testMultisetEmplace<TCT::multiset<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp b/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
index 29a746696..7f7a00c15 100644
--- a/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -56,4 +56,6 @@ int main()
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp b/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
index b0da5f4f2..e29e7b484 100644
--- a/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -69,4 +69,6 @@ int main()
         assert(*r == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp b/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
index 07b8000d9..242b9d7f6 100644
--- a/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -81,4 +81,6 @@ int main()
         assert(*next(m.begin(), 8) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp b/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
index 3dea1f8a2..e905c5c40 100644
--- a/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> M;
@@ -70,4 +70,6 @@ int main()
         assert(m.size() == 4);
         assert(*r == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_node_type.pass.cpp b/test/std/containers/associative/multiset/insert_node_type.pass.cpp
index b8aad6c8c..7cf2cebfb 100644
--- a/test/std/containers/associative/multiset/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_node_type.pass.cpp
@@ -67,10 +67,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multiset<int> m;
     test(m);
     std::multiset<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp b/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
index 3e5b40b96..d4d6871fb 100644
--- a/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
@@ -49,10 +49,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multiset<int> m;
     test(m);
     std::multiset<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/insert_rv.pass.cpp b/test/std/containers/associative/multiset/insert_rv.pass.cpp
index 9d50c617d..3f73a2813 100644
--- a/test/std/containers/associative/multiset/insert_rv.pass.cpp
+++ b/test/std/containers/associative/multiset/insert_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> M;
@@ -70,4 +70,6 @@ int main()
         assert(m.size() == 4);
         assert(*r == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/iterator.pass.cpp b/test/std/containers/associative/multiset/iterator.pass.cpp
index bda2c7faa..4ab1d79a0 100644
--- a/test/std/containers/associative/multiset/iterator.pass.cpp
+++ b/test/std/containers/associative/multiset/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -213,4 +213,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/lower_bound.pass.cpp b/test/std/containers/associative/multiset/lower_bound.pass.cpp
index dd9fdf70c..6d31f04c8 100644
--- a/test/std/containers/associative/multiset/lower_bound.pass.cpp
+++ b/test/std/containers/associative/multiset/lower_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -220,4 +220,6 @@ int main()
     assert(r == next(m.begin(), 9));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/max_size.pass.cpp b/test/std/containers/associative/multiset/max_size.pass.cpp
index 64baa6cb0..5986df295 100644
--- a/test/std/containers/associative/multiset/max_size.pass.cpp
+++ b/test/std/containers/associative/multiset/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -46,4 +46,6 @@ int main()
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/merge.pass.cpp b/test/std/containers/associative/multiset/merge.pass.cpp
index 9d566484c..e7e05b155 100644
--- a/test/std/containers/associative/multiset/merge.pass.cpp
+++ b/test/std/containers/associative/multiset/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_comparator
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::multiset<int> src{1, 3, 5};
@@ -145,4 +145,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
index 4debe7b42..9ceac884b 100644
--- a/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::less<int> C;
     typedef test_allocator<int> A;
@@ -25,4 +25,6 @@ int main()
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
index f325fe919..c84b04293 100644
--- a/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -51,4 +51,6 @@ int main()
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
index b628d50ff..d35de106f 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     const std::multiset<int, C> m(C(3));
@@ -29,4 +29,6 @@ int main()
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     assert(m.value_comp() == C(3));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
index e06c21719..f044b2790 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     typedef test_allocator<int> A;
@@ -27,4 +27,6 @@ int main()
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
index 09c2ac093..ae987c64c 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::multiset<int, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
index a055b15fc..ac196b5ae 100644
--- a/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -115,4 +115,6 @@ int main()
         assert(*next(mo.begin(), 8) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
index 4466438ca..25e6d6efb 100644
--- a/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -64,4 +64,6 @@ int main()
     assert(*next(mo.begin(), 6) == 3);
     assert(*next(mo.begin(), 7) == 3);
     assert(*next(mo.begin(), 8) == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
index 0efa8bec6..7992c7cae 100644
--- a/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -134,4 +134,6 @@ int main()
         assert(*next(mo.begin(), 7) == 3);
         assert(*next(mo.begin(), 8) == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
index a84bc6d10..88c5244f8 100644
--- a/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::multiset<int> m;
@@ -50,4 +50,6 @@ int main()
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
index 747e948ed..7fa25ac47 100644
--- a/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -53,4 +53,6 @@ int main()
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
index e26828265..8a18a2977 100644
--- a/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> C;
@@ -47,4 +47,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
index c0a682e91..68a74e80c 100644
--- a/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -66,4 +66,6 @@ int main()
     assert(*++i == V(6));
     assert(m.get_allocator() == a);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
index 719476c7d..cf4c11dcf 100644
--- a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > Cmp;
     typedef std::multiset<int, Cmp> C;
@@ -34,4 +34,6 @@ int main()
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
index 61a1f3ca0..5f26864cd 100644
--- a/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > Cmp;
     typedef test_allocator<int> A;
@@ -37,4 +37,6 @@ int main()
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
     assert(m.get_allocator() == A(4));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
index a1806ecf9..9d521c279 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -79,4 +79,6 @@ int main()
     assert(*next(m.begin(), 8) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
index 3a37ac014..82d9f4aea 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
@@ -22,7 +22,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -91,4 +91,6 @@ int main()
     assert(m.get_allocator() == a);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
index 77f6b10c4..25b4364c1 100644
--- a/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -49,4 +49,6 @@ int main()
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
index 8d43c098e..0d6cc72a6 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -113,4 +113,6 @@ int main()
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
index c91a97b49..1abe5b928 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -184,4 +184,6 @@ int main()
         }
         assert(Counter_base::gConstructed == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
index 263e48b46..6f584f22c 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -180,4 +180,6 @@ int main()
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
index aa164edf0..026fc1ba7 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> C;
@@ -53,4 +53,6 @@ int main()
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
index 41fd86269..88bbb59a4 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -51,4 +51,6 @@ int main()
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp b/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
index 19a0d131f..84d665cb1 100644
--- a/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::multiset<int>>();
     test<std::multiset<int, std::less<int>, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::multiset<long>>();
     test<std::multiset<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp b/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
index be1132502..9ac0f1709 100644
--- a/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -173,4 +173,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp b/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
index 9b6d021f5..a3bbf551d 100644
--- a/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     {
@@ -163,4 +163,6 @@ int main()
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp b/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
index 367e6e1c9..47a0d411f 100644
--- a/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> C;
@@ -136,4 +136,6 @@ int main()
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/scary.pass.cpp b/test/std/containers/associative/multiset/scary.pass.cpp
index 329f9f18f..5065ab96e 100644
--- a/test/std/containers/associative/multiset/scary.pass.cpp
+++ b/test/std/containers/associative/multiset/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <set>
 
-int main()
+int main(int, char**)
 {
     typedef std::set<int> M1;
     typedef std::multiset<int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/size.pass.cpp b/test/std/containers/associative/multiset/size.pass.cpp
index ccb3f0f7a..bb5616e9a 100644
--- a/test/std/containers/associative/multiset/size.pass.cpp
+++ b/test/std/containers/associative/multiset/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> M;
@@ -55,4 +55,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/types.pass.cpp b/test/std/containers/associative/multiset/types.pass.cpp
index 3ee2fc570..96e8ec4f0 100644
--- a/test/std/containers/associative/multiset/types.pass.cpp
+++ b/test/std/containers/associative/multiset/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -66,4 +66,6 @@ int main()
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/multiset/upper_bound.pass.cpp b/test/std/containers/associative/multiset/upper_bound.pass.cpp
index f2796d7b4..99a7e374d 100644
--- a/test/std/containers/associative/multiset/upper_bound.pass.cpp
+++ b/test/std/containers/associative/multiset/upper_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -219,4 +219,6 @@ int main()
     assert(r == next(m.begin(), 9));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/allocator_mismatch.fail.cpp b/test/std/containers/associative/set/allocator_mismatch.fail.cpp
index ed3601968..69e49351e 100644
--- a/test/std/containers/associative/set/allocator_mismatch.fail.cpp
+++ b/test/std/containers/associative/set/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <set>
 
-int main()
+int main(int, char**)
 {
     std::set<int, std::less<int>, std::allocator<long> > s;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/clear.pass.cpp b/test/std/containers/associative/set/clear.pass.cpp
index 3f84ee480..0650e912f 100644
--- a/test/std/containers/associative/set/clear.pass.cpp
+++ b/test/std/containers/associative/set/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -62,4 +62,6 @@ int main()
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/count.pass.cpp b/test/std/containers/associative/set/count.pass.cpp
index e915b1cde..8866aa7f0 100644
--- a/test/std/containers/associative/set/count.pass.cpp
+++ b/test/std/containers/associative/set/count.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -167,4 +167,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/count_transparent.pass.cpp b/test/std/containers/associative/set/count_transparent.pass.cpp
index e8490e6de..d94188def 100644
--- a/test/std/containers/associative/set/count_transparent.pass.cpp
+++ b/test/std/containers/associative/set/count_transparent.pass.cpp
@@ -42,9 +42,11 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::set<std::pair<int, int>, Comp> s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/emplace.pass.cpp b/test/std/containers/associative/set/emplace.pass.cpp
index fdabf02a8..e48f2e1e4 100644
--- a/test/std/containers/associative/set/emplace.pass.cpp
+++ b/test/std/containers/associative/set/emplace.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<DefaultOnly> M;
@@ -84,4 +84,6 @@ int main()
         assert(m.size() == 1);
         assert(*r.first == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/emplace_hint.pass.cpp b/test/std/containers/associative/set/emplace_hint.pass.cpp
index 441adaf21..a7ed7266b 100644
--- a/test/std/containers/associative/set/emplace_hint.pass.cpp
+++ b/test/std/containers/associative/set/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<DefaultOnly> M;
@@ -77,4 +77,6 @@ int main()
         assert(m.size() == 1);
         assert(*r == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/empty.fail.cpp b/test/std/containers/associative/set/empty.fail.cpp
index 7954f6f49..fc5856fbd 100644
--- a/test/std/containers/associative/set/empty.fail.cpp
+++ b/test/std/containers/associative/set/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::set<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/empty.pass.cpp b/test/std/containers/associative/set/empty.pass.cpp
index 50ce5dd3b..c00ab68ff 100644
--- a/test/std/containers/associative/set/empty.pass.cpp
+++ b/test/std/containers/associative/set/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> M;
@@ -39,4 +39,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/equal_range.pass.cpp b/test/std/containers/associative/set/equal_range.pass.cpp
index da221aa54..5c4370611 100644
--- a/test/std/containers/associative/set/equal_range.pass.cpp
+++ b/test/std/containers/associative/set/equal_range.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -367,4 +367,6 @@ int main()
     assert(r.second == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/equal_range_transparent.pass.cpp b/test/std/containers/associative/set/equal_range_transparent.pass.cpp
index c091aa6b5..b69ff2d52 100644
--- a/test/std/containers/associative/set/equal_range_transparent.pass.cpp
+++ b/test/std/containers/associative/set/equal_range_transparent.pass.cpp
@@ -44,7 +44,7 @@ struct Comp {
   }
 };
 
-int main() {
+int main(int, char**) {
   std::set<std::pair<int, int>, Comp> s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
 
   auto er = s.equal_range(1);
@@ -56,4 +56,6 @@ int main() {
   }
 
   assert(nels == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/erase_iter.pass.cpp b/test/std/containers/associative/set/erase_iter.pass.cpp
index 99650d3d0..49ce4f29e 100644
--- a/test/std/containers/associative/set/erase_iter.pass.cpp
+++ b/test/std/containers/associative/set/erase_iter.pass.cpp
@@ -25,7 +25,7 @@ struct TemplateConstructor
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -199,4 +199,6 @@ int main()
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/erase_iter_iter.pass.cpp b/test/std/containers/associative/set/erase_iter_iter.pass.cpp
index b98d83ad8..86fd52c2c 100644
--- a/test/std/containers/associative/set/erase_iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -137,4 +137,6 @@ int main()
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/erase_key.pass.cpp b/test/std/containers/associative/set/erase_key.pass.cpp
index da3ea5c14..3ceec8850 100644
--- a/test/std/containers/associative/set/erase_key.pass.cpp
+++ b/test/std/containers/associative/set/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -199,4 +199,6 @@ int main()
         assert(i == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/extract_iterator.pass.cpp b/test/std/containers/associative/set/extract_iterator.pass.cpp
index da95331f7..1ba13e318 100644
--- a/test/std/containers/associative/set/extract_iterator.pass.cpp
+++ b/test/std/containers/associative/set/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::set<int>;
@@ -56,4 +56,6 @@ int main()
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/extract_key.pass.cpp b/test/std/containers/associative/set/extract_key.pass.cpp
index 68f24f654..4417e8636 100644
--- a/test/std/containers/associative/set/extract_key.pass.cpp
+++ b/test/std/containers/associative/set/extract_key.pass.cpp
@@ -43,7 +43,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::set<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/find.pass.cpp b/test/std/containers/associative/set/find.pass.cpp
index 50b779afd..cda1ea87a 100644
--- a/test/std/containers/associative/set/find.pass.cpp
+++ b/test/std/containers/associative/set/find.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -237,4 +237,6 @@ int main()
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/gcc_workaround.pass.cpp b/test/std/containers/associative/set/gcc_workaround.pass.cpp
index 2b923b773..5f4947b54 100644
--- a/test/std/containers/associative/set/gcc_workaround.pass.cpp
+++ b/test/std/containers/associative/set/gcc_workaround.pass.cpp
@@ -15,7 +15,4 @@ std::set<int> s;
 using std::map;
 using std::multimap;
 
-int main(void)
-{
-       return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/test/std/containers/associative/set/incomplete_type.pass.cpp b/test/std/containers/associative/set/incomplete_type.pass.cpp
index 96b2bbf59..d3b93c599 100644
--- a/test/std/containers/associative/set/incomplete_type.pass.cpp
+++ b/test/std/containers/associative/set/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
index 8c60e699a..11be14b02 100644
--- a/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -20,9 +20,11 @@
 #include "container_test_types.h"
 #include "../../set_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testSetInsert<TCT::set<> >();
   testSetEmplace<TCT::set<> >();
   testSetEmplaceHint<TCT::set<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_cv.pass.cpp b/test/std/containers/associative/set/insert_cv.pass.cpp
index d29a796ba..a97e76eb5 100644
--- a/test/std/containers/associative/set/insert_cv.pass.cpp
+++ b/test/std/containers/associative/set/insert_cv.pass.cpp
@@ -53,7 +53,7 @@ void do_insert_cv_test()
     assert(*r.first == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_cv_test<std::set<int> >();
 #if TEST_STD_VER >= 11
@@ -62,4 +62,6 @@ int main()
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_initializer_list.pass.cpp b/test/std/containers/associative/set/insert_initializer_list.pass.cpp
index 46fdecd4f..ce5cc6fd2 100644
--- a/test/std/containers/associative/set/insert_initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/insert_initializer_list.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -56,4 +56,6 @@ int main()
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_iter_cv.pass.cpp b/test/std/containers/associative/set/insert_iter_cv.pass.cpp
index ab8834e6a..be27e5e4e 100644
--- a/test/std/containers/associative/set/insert_iter_cv.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_cv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -69,4 +69,6 @@ int main()
         assert(*r == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_iter_iter.pass.cpp b/test/std/containers/associative/set/insert_iter_iter.pass.cpp
index bf55e31a8..35c2dca30 100644
--- a/test/std/containers/associative/set/insert_iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -69,4 +69,6 @@ int main()
         assert(*next(m.begin(), 2) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_iter_rv.pass.cpp b/test/std/containers/associative/set/insert_iter_rv.pass.cpp
index dfe3b52da..08eba9fe6 100644
--- a/test/std/containers/associative/set/insert_iter_rv.pass.cpp
+++ b/test/std/containers/associative/set/insert_iter_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> M;
@@ -70,4 +70,6 @@ int main()
         assert(m.size() == 3);
         assert(*r == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_node_type.pass.cpp b/test/std/containers/associative/set/insert_node_type.pass.cpp
index 51826f4fd..188aea2bb 100644
--- a/test/std/containers/associative/set/insert_node_type.pass.cpp
+++ b/test/std/containers/associative/set/insert_node_type.pass.cpp
@@ -73,10 +73,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::set<int> m;
     test(m);
     std::set<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_node_type_hint.pass.cpp b/test/std/containers/associative/set/insert_node_type_hint.pass.cpp
index 2595a3ca2..6e8c14099 100644
--- a/test/std/containers/associative/set/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/associative/set/insert_node_type_hint.pass.cpp
@@ -51,10 +51,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::set<int> m;
     test(m);
     std::set<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/insert_rv.pass.cpp b/test/std/containers/associative/set/insert_rv.pass.cpp
index 567243ad5..092fd8a71 100644
--- a/test/std/containers/associative/set/insert_rv.pass.cpp
+++ b/test/std/containers/associative/set/insert_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> M;
@@ -78,4 +78,6 @@ int main()
         assert(m.size() == 3);
         assert(*r.first == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/iterator.pass.cpp b/test/std/containers/associative/set/iterator.pass.cpp
index 5212e3fcf..da0f9a7b9 100644
--- a/test/std/containers/associative/set/iterator.pass.cpp
+++ b/test/std/containers/associative/set/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -209,4 +209,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/lower_bound.pass.cpp b/test/std/containers/associative/set/lower_bound.pass.cpp
index b363524d4..9a25950a8 100644
--- a/test/std/containers/associative/set/lower_bound.pass.cpp
+++ b/test/std/containers/associative/set/lower_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -334,4 +334,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/max_size.pass.cpp b/test/std/containers/associative/set/max_size.pass.cpp
index 8c2c5fd28..e37bfe714 100644
--- a/test/std/containers/associative/set/max_size.pass.cpp
+++ b/test/std/containers/associative/set/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -46,4 +46,6 @@ int main()
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/merge.pass.cpp b/test/std/containers/associative/set/merge.pass.cpp
index a8b22ea3d..62e76ba06 100644
--- a/test/std/containers/associative/set/merge.pass.cpp
+++ b/test/std/containers/associative/set/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_comparator
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::set<int> src{1, 3, 5};
@@ -145,4 +145,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/alloc.pass.cpp b/test/std/containers/associative/set/set.cons/alloc.pass.cpp
index 87bdb7aec..591b28c18 100644
--- a/test/std/containers/associative/set/set.cons/alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/alloc.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::less<int> C;
     typedef test_allocator<int> A;
@@ -25,4 +25,6 @@ int main()
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp b/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
index 269ae1175..0127b1d81 100644
--- a/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -51,4 +51,6 @@ int main()
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/compare.pass.cpp b/test/std/containers/associative/set/set.cons/compare.pass.cpp
index 4a6978d95..a4e9718e2 100644
--- a/test/std/containers/associative/set/set.cons/compare.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/compare.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     const std::set<int, C> m(C(3));
@@ -29,4 +29,6 @@ int main()
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     assert(m.value_comp() == C(3));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
index 8264c3f81..41c7d0289 100644
--- a/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     typedef test_allocator<int> A;
@@ -27,4 +27,6 @@ int main()
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
index 84c0b4ea0..58f678dd1 100644
--- a/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::set<int, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/copy.pass.cpp b/test/std/containers/associative/set/set.cons/copy.pass.cpp
index 529d951d2..2e256aa17 100644
--- a/test/std/containers/associative/set/set.cons/copy.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/copy.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -91,4 +91,6 @@ int main()
         assert(*next(mo.begin(), 2) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
index 09e7f84ee..6b1010c33 100644
--- a/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -52,4 +52,6 @@ int main()
     assert(*mo.begin() == 1);
     assert(*next(mo.begin()) == 2);
     assert(*next(mo.begin(), 2) == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp b/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
index d89c27813..c1f37f83d 100644
--- a/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -105,4 +105,6 @@ int main()
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/default.pass.cpp b/test/std/containers/associative/set/set.cons/default.pass.cpp
index 16137d7cc..88dc3a262 100644
--- a/test/std/containers/associative/set/set.cons/default.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::set<int> m;
@@ -50,4 +50,6 @@ int main()
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
index 0c25901be..0305e20f2 100644
--- a/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -53,4 +53,6 @@ int main()
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
index 9ee68bf6d..a06a47168 100644
--- a/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> C;
@@ -47,4 +47,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp b/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
index a0cba90bd..e4742bbda 100644
--- a/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -49,4 +49,6 @@ int main()
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp b/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
index a0448cdbc..cf4b78af9 100644
--- a/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > Cmp;
     typedef std::set<int, Cmp> C;
@@ -34,4 +34,6 @@ int main()
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
index 40990948b..161cdd8c1 100644
--- a/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
@@ -21,7 +21,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > Cmp;
@@ -58,4 +58,6 @@ int main()
     assert(*++i == V(6));
     assert(m.get_allocator() == A(4));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
index 913efe0da..25143a7df 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -67,4 +67,6 @@ int main()
     assert(*next(m.begin(), 2) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
index 6e3625d05..bf8b97098 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
@@ -26,7 +26,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -83,4 +83,6 @@ int main()
     assert(m.get_allocator() == a);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp b/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
index b75cccc4e..f9c2e4a98 100644
--- a/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -43,4 +43,6 @@ int main()
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/move.pass.cpp b/test/std/containers/associative/set/set.cons/move.pass.cpp
index b2d7b0429..516274efc 100644
--- a/test/std/containers/associative/set/set.cons/move.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -101,4 +101,6 @@ int main()
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
index 7bae3ed21..db7933e92 100644
--- a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -185,4 +185,6 @@ int main()
         assert(Counter_base::gConstructed == 0);
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/move_assign.pass.cpp b/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
index bbd787151..ba5c767f3 100644
--- a/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -180,4 +180,6 @@ int main()
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
index 408227e8d..f6e3c9f32 100644
--- a/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> C;
@@ -53,4 +53,6 @@ int main()
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp b/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
index 6945aa39e..2bcd26de6 100644
--- a/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@ struct some_comp
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -51,4 +51,6 @@ int main()
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp b/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
index 3eecab797..43a60d79c 100644
--- a/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
+++ b/test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
@@ -55,7 +55,7 @@ void test()
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::set<int>>();
     test<std::set<int, std::less<int>, min_allocator<int>>> ();
@@ -63,4 +63,6 @@ int main()
 
     test<std::set<long>>();
     test<std::set<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.special/member_swap.pass.cpp b/test/std/containers/associative/set/set.special/member_swap.pass.cpp
index 02324a36a..455c34ec8 100644
--- a/test/std/containers/associative/set/set.special/member_swap.pass.cpp
+++ b/test/std/containers/associative/set/set.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -173,4 +173,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp b/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
index 2420dabf6..b111de9ca 100644
--- a/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
+++ b/test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     {
@@ -163,4 +163,6 @@ int main()
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp b/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
index fc0eba646..9fd68f663 100644
--- a/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> C;
@@ -137,4 +137,6 @@ int main()
 #endif // _LIBCPP_VERSION
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/size.pass.cpp b/test/std/containers/associative/set/size.pass.cpp
index 93b234725..b73d83376 100644
--- a/test/std/containers/associative/set/size.pass.cpp
+++ b/test/std/containers/associative/set/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> M;
@@ -55,4 +55,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/types.pass.cpp b/test/std/containers/associative/set/types.pass.cpp
index 3b8c0983b..5c7bd25a5 100644
--- a/test/std/containers/associative/set/types.pass.cpp
+++ b/test/std/containers/associative/set/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -66,4 +66,6 @@ int main()
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/associative/set/upper_bound.pass.cpp b/test/std/containers/associative/set/upper_bound.pass.cpp
index 315268a60..3649a5c04 100644
--- a/test/std/containers/associative/set/upper_bound.pass.cpp
+++ b/test/std/containers/associative/set/upper_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -333,4 +333,6 @@ int main()
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/nothing_to_do.pass.cpp b/test/std/containers/container.adaptors/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.adaptors/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.adaptors/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
index 293356b38..59547203b 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
@@ -40,9 +40,11 @@ struct test
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q((test_allocator<int>(3)));
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.c.size() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
index 58d61b70e..40f6bc473 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
@@ -40,9 +40,11 @@ struct test
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q(std::less<int>(), test_allocator<int>(3));
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.c.size() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
index 39c495565..1f3dd7fbd 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
@@ -51,7 +51,7 @@ struct test
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::vector<int, test_allocator<int> > C;
     C v = make<C>(5);
@@ -59,4 +59,6 @@ int main()
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.size() == 5);
     assert(q.top() == 4);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
index 460906473..3956f9b97 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
@@ -51,11 +51,13 @@ struct test
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::vector<int, test_allocator<int> > C;
     test<int> q(std::less<int>(), make<C>(5), test_allocator<int>(3));
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.size() == 5);
     assert(q.top() == 4);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
index 69ed27c07..c46171843 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
@@ -45,7 +45,7 @@ struct test
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     test<int> qo(std::less<int>(),
                       make<std::vector<int, test_allocator<int> > >(5),
@@ -54,4 +54,6 @@ int main()
     assert(q.size() == 5);
     assert(q.c.get_allocator() == test_allocator<int>(6));
     assert(q.top() == int(4));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
index d1ca38e02..98dc207c1 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
@@ -53,7 +53,7 @@ struct test
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> qo(std::less<MoveOnly>(),
                       make<std::vector<MoveOnly, test_allocator<MoveOnly> > >(5),
@@ -62,4 +62,6 @@ int main()
     assert(q.size() == 5);
     assert(q.c.get_allocator() == test_allocator<MoveOnly>(6));
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
index 12c642561..5b7760d05 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
@@ -24,7 +24,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v = make<std::vector<int> >(5);
     std::priority_queue<int, std::vector<int>, std::greater<int> > qo(std::greater<int>(), v);
@@ -32,4 +32,6 @@ int main()
     q = qo;
     assert(q.size() == 5);
     assert(q.top() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
index 614992094..20f62d9bf 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
@@ -29,11 +29,13 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> qo(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
     std::priority_queue<MoveOnly> q;
     q = std::move(qo);
     assert(q.size() == 5);
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
index a195b10fc..02f1bcaf0 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q((std::less<int>()));
     assert(q.size() == 0);
@@ -23,4 +23,6 @@ int main()
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
index 561b5d48d..487b86c5f 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
@@ -24,10 +24,12 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v = make<std::vector<int> >(5);
     std::priority_queue<int, std::vector<int>, std::greater<int> > q(std::greater<int>(), v);
     assert(q.size() == 5);
     assert(q.top() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
index cb3b97997..47980032c 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
@@ -29,9 +29,11 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> q(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
     assert(q.size() == 5);
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
index 1c63f7152..fa8bae2b9 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
@@ -24,11 +24,13 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v = make<std::vector<int> >(5);
     std::priority_queue<int, std::vector<int>, std::greater<int> > qo(std::greater<int>(), v);
     std::priority_queue<int, std::vector<int>, std::greater<int> > q = qo;
     assert(q.size() == 5);
     assert(q.top() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
index ae0e7badb..4c8dd524a 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@ int main()
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
index d1cda2029..d2afe72ca 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
@@ -15,11 +15,13 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     int* an = a + sizeof(a)/sizeof(a[0]);
     std::priority_queue<int> q(a, an);
     assert(q.size() == static_cast<std::size_t>(an - a));
     assert(q.top() == 8);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
index c147b5cfd..caee12f0f 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
@@ -16,7 +16,7 @@
 #include <functional>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     int* an = a + sizeof(a)/sizeof(a[0]);
@@ -24,4 +24,6 @@ int main()
         q(a, an, std::greater<int>());
     assert(q.size() == static_cast<std::size_t>(an - a));
     assert(q.top() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
index b5dd515da..0b0766792 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     const int n = sizeof(a)/sizeof(a[0]);
@@ -23,4 +23,6 @@ int main()
     std::priority_queue<int> q(a+n/2, a+n, std::less<int>(), v);
     assert(q.size() == n);
     assert(q.top() == 8);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
index f2f78685f..6bc4417f4 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     const int n = sizeof(a)/sizeof(a[0]);
@@ -28,4 +28,6 @@ int main()
                                     std::vector<MoveOnly>(a, a+n/2));
     assert(q.size() == n);
     assert(q.top() == MoveOnly(8));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
index 445bdb566..415801244 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
@@ -29,10 +29,12 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> qo(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
     std::priority_queue<MoveOnly> q = std::move(qo);
     assert(q.size() == 5);
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
index a37e372ed..a6e579a44 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
@@ -17,7 +17,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -54,4 +54,6 @@ int main()
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
index f175c7d14..45d39ad3e 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
@@ -38,7 +38,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -119,4 +119,6 @@ int main()
     assert(pri.size() == 4);
     assert(pri.top() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
index fa0e92a16..d738a553e 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -31,4 +31,6 @@ int main()
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
index a6418a3c7..af583a9e2 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
index 8c3800ba2..3fbd53dc4 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
index ae6eb4b08..7c6b5f213 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
index 5e5dd9f12..928533075 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "../../../Emplaceable.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<Emplaceable> q;
     q.emplace(1, 2.5);
@@ -28,4 +28,6 @@ int main()
     assert(q.top() == Emplaceable(3, 4.5));
     q.emplace(2, 3.5);
     assert(q.top() == Emplaceable(3, 4.5));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
index 33b97d533..698553d33 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::priority_queue<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
index 60499b853..f8f9279d5 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     assert(q.empty());
@@ -23,4 +23,6 @@ int main()
     assert(!q.empty());
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
index b6bcb4a72..a6fc9509c 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     q.push(1);
@@ -30,4 +30,6 @@ int main()
     assert(q.top() == 1);
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
index 8edbe1ad1..01c0ab618 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     q.push(1);
@@ -24,4 +24,6 @@ int main()
     assert(q.top() == 3);
     q.push(2);
     assert(q.top() == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
index 00bdf0c7e..cf474dec5 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> q;
     q.push(1);
@@ -28,4 +28,6 @@ int main()
     assert(q.top() == 3);
     q.push(2);
     assert(q.top() == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
index 51eef9eda..393a97c28 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@ int main()
     assert(q.size() == 1);
     q.pop();
     assert(q.size() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
index 995e1742a..bc3f453d8 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q1;
     std::priority_queue<int> q2;
@@ -26,4 +26,6 @@ int main()
     assert(q1.empty());
     assert(q2.size() == 3);
     assert(q2.top() == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
index 22a8174b3..ea0e489f6 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     q.push(1);
@@ -24,4 +24,6 @@ int main()
     assert(q.top() == 3);
     q.push(2);
     assert(q.top() == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
index 2c9a39f66..bc75df0d3 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q1;
     std::priority_queue<int> q2;
@@ -28,4 +28,6 @@ int main()
     assert(q1.empty());
     assert(q2.size() == 3);
     assert(q2.top() == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
index f2194ccf8..ad4254c2b 100644
--- a/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
@@ -22,10 +22,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
index 431a4d0d5..244028e44 100644
--- a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
@@ -27,8 +27,10 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 //  LWG#2566 says that the first template param must match the second one's value type
     std::priority_queue<double, std::deque<int>> t;
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/types.pass.cpp b/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
index 6084e5906..547128190 100644
--- a/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/types.pass.cpp
@@ -50,7 +50,7 @@ struct C
     typedef int size_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_same<std::priority_queue<int>::container_type, std::vector<int> >::value), "");
     static_assert(( std::is_same<std::priority_queue<int, std::deque<int> >::container_type, std::deque<int> >::value), "");
@@ -64,4 +64,6 @@ int main()
     static_assert(( std::uses_allocator<std::priority_queue<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::priority_queue<int, C>, std::allocator<int> >::value), "");
     test t;
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
index d2a85a348..8d916f767 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
@@ -31,8 +31,10 @@ struct test
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test q(test_allocator<int>(3));
     assert(q.get_allocator() == test_allocator<int>(3));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
index fc3549d2d..56272064f 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
@@ -44,7 +44,7 @@ struct test
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     C d = make<C>(5);
     test q(d, test_allocator<int>(4));
@@ -55,4 +55,6 @@ int main()
         assert(q.front() == d[i]);
         q.pop();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
index 6c7fbbc81..8a66c6f12 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
@@ -42,10 +42,12 @@ struct test
     allocator_type get_allocator() {return this->c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q(make<C>(5), test_allocator<int>(4));
     test<int> q2(q, test_allocator<int>(5));
     assert(q2.get_allocator() == test_allocator<int>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
index cc6cb5cdb..3af4fb0da 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
@@ -48,9 +48,11 @@ struct test
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     assert(q.get_allocator() == test_allocator<MoveOnly>(4));
     assert(q.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
index cac8bf3cd..29a742df7 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
@@ -48,10 +48,12 @@ struct test
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     test<MoveOnly> q2(std::move(q), test_allocator<MoveOnly>(5));
     assert(q2.get_allocator() == test_allocator<MoveOnly>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
index e9c41a0b6..dad35d2d1 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
@@ -24,7 +24,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> d = make<std::deque<int> >(5);
     std::queue<int> q(d);
@@ -34,4 +34,6 @@ int main()
         assert(q.front() == d[i]);
         q.pop();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
index 35c2fa013..19e46a236 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
@@ -23,9 +23,11 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q(make<std::deque<int> >(5));
     std::queue<int> q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
index 0a1d3dd96..c5c8b17a6 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::queue<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
@@ -24,4 +24,6 @@ int main()
     assert(q.size() == 2);
     assert(q.front() == 1);
     assert(q.back() == 2);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
index a9def3e33..c275d5d60 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
@@ -29,10 +29,12 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::queue<MoveOnly> q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
index 00aba51c3..3812ce916 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
@@ -29,8 +29,10 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     assert(q.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp b/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
index eecb0343b..00b39c6a9 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
@@ -17,7 +17,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -42,4 +42,6 @@ int main()
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
index 45a6f2e75..247da2a3d 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
@@ -33,7 +33,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -87,4 +87,6 @@ int main()
     assert(que.back() == 3);
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
index a53dd9492..1200f2e2f 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -29,4 +29,6 @@ int main()
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
index 4c87d15e0..18e42ea3a 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::queue<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
index 93f69059f..a82ab8fa4 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
@@ -20,10 +20,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
index 24e96edc5..e4c170a8b 100644
--- a/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -30,4 +30,6 @@ int main()
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
index 5fe6b70c6..98385a6f7 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
@@ -23,10 +23,12 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q(make<std::deque<int> >(5));
     std::queue<int> q2;
     q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
index 87c9ad197..de30e5cfe 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
@@ -29,11 +29,13 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::queue<MoveOnly> q2;
     q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
index 115360e07..cb115c702 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -22,4 +22,6 @@ int main()
     q.push(3);
     int& ir = q.back();
     assert(ir == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
index 158aa83a9..3a6e4c890 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@ int main()
     const std::queue<int>& cqr = q;
     const int& cir = cqr.back();
     assert(cir == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
index a8e8791ac..74afcce97 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
@@ -37,7 +37,7 @@ void test_return_type() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<std::queue<int> > ();
     test_return_type<std::queue<int, std::list<int> > > ();
@@ -61,4 +61,6 @@ int main()
     assert(q.size() == 3);
     assert(q.front() == Emplaceable(1, 2.5));
     assert(q.back() == Emplaceable(3, 4.5));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp b/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
index f53f9a805..454bf32be 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::queue<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
index 095512c21..cc0fc56b7 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.empty());
@@ -21,4 +21,6 @@ int main()
     assert(!q.empty());
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
index 7ce29976b..9c8d253fb 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -22,4 +22,6 @@ int main()
     q.push(3);
     int& ir = q.front();
     assert(ir == 1);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
index edcb21ea2..5ad1ae97a 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@ int main()
     const std::queue<int>& cqr = q;
     const int& cir = cqr.front();
     assert(cir == 1);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
index 587cf26c3..128cda512 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -33,4 +33,6 @@ int main()
     assert(q.back() == 3);
     q.pop();
     assert(q.size() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
index a9e962f8a..b2a784ccf 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     q.push(1);
@@ -28,4 +28,6 @@ int main()
     assert(q.size() == 3);
     assert(q.front() == 1);
     assert(q.back() == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
index aafc95635..17c442b15 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q;
     q.push(MoveOnly(1));
@@ -32,4 +32,6 @@ int main()
     assert(q.size() == 3);
     assert(q.front() == MoveOnly(1));
     assert(q.back() == MoveOnly(3));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
index f3ecaa5c4..fb4fdfcac 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
@@ -13,10 +13,12 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
     q.push(1);
     assert(q.size() == 1);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
index 9017d2127..3635cea4a 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
@@ -23,7 +23,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -32,4 +32,6 @@ int main()
     q1.swap(q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
index b9e018ca1..041008ce6 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
@@ -12,8 +12,10 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 //  LWG#2566 says that the first template param must match the second one's value type
     std::queue<double, std::deque<int>> t;
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp b/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
index edc41c1a3..8623710ea 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
@@ -43,7 +43,7 @@ struct C
     typedef int size_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_same<std::queue<int>::container_type, std::deque<int> >::value), "");
     static_assert(( std::is_same<std::queue<int, std::vector<int> >::container_type, std::vector<int> >::value), "");
@@ -54,4 +54,6 @@ int main()
     static_assert(( std::uses_allocator<std::queue<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::queue<int, C>, std::allocator<int> >::value), "");
     test t;
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp b/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
index ee36779b5..b4a3327d8 100644
--- a/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
@@ -27,7 +27,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -36,4 +36,6 @@ int main()
     assert(q1 == q1_save);
     assert(q1 != q2);
     assert(q2 == q2_save);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp b/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
index 66ef66c7b..a8eeb1be1 100644
--- a/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
@@ -33,7 +33,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -41,4 +41,6 @@ int main()
     assert(q2 > q1);
     assert(q1 <= q2);
     assert(q2 >= q1);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp b/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
index fcaec66d7..1adc4f1f4 100644
--- a/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
@@ -24,7 +24,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -33,4 +33,6 @@ int main()
     swap(q1, q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
index 81d728a27..b8cc387d1 100644
--- a/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::queue<MoveOnly> C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
index c0023c401..9fb09b158 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
@@ -31,8 +31,10 @@ struct test
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test q(test_allocator<int>(3));
     assert(q.get_allocator() == test_allocator<int>(3));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
index ef4d25e05..b0c6f4fca 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
@@ -44,7 +44,7 @@ struct test
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     C d = make<C>(5);
     test q(d, test_allocator<int>(4));
@@ -55,4 +55,6 @@ int main()
         assert(q.top() == d[d.size() - i - 1]);
         q.pop();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
index f7c0a9620..0d8481228 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
@@ -42,10 +42,12 @@ struct test
     allocator_type get_allocator() {return this->c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q(make<C>(5), test_allocator<int>(4));
     test<int> q2(q, test_allocator<int>(5));
     assert(q2.get_allocator() == test_allocator<int>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
index f33f638b8..5181c6739 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
@@ -48,9 +48,11 @@ struct test
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     assert(q.get_allocator() == test_allocator<MoveOnly>(4));
     assert(q.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
index 2889763ec..c5ff35d2d 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
@@ -48,10 +48,12 @@ struct test
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     test<MoveOnly> q2(std::move(q), test_allocator<MoveOnly>(5));
     assert(q2.get_allocator() == test_allocator<MoveOnly>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
index 7db358b3f..c649e238f 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
@@ -24,7 +24,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> d = make<std::deque<int> >(5);
     std::stack<int> q(d);
@@ -34,4 +34,6 @@ int main()
         assert(q.top() == d[d.size() - i - 1]);
         q.pop();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
index 2bbf7cc93..ef3606366 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
@@ -23,9 +23,11 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q(make<std::deque<int> >(5));
     std::stack<int> q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
index 731b2fe4e..460cf27ec 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::stack<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
@@ -24,4 +24,6 @@ int main()
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
index e5c846df1..86f4414c9 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
@@ -29,10 +29,12 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::stack<MoveOnly> q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
index 9ead91521..28fb5655f 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
@@ -29,8 +29,10 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     assert(q.size() == 5);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp b/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
index bfddd8b59..894906fc4 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
@@ -24,7 +24,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -49,4 +49,6 @@ int main()
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
index ec724b063..dd5ab91a0 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
@@ -35,7 +35,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -90,4 +90,6 @@ int main()
     assert(stk.top() == 3);
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
index 2e901843e..d06e2865e 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -30,4 +30,6 @@ int main()
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
index 616f46418..7c5fd6486 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::stack<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
index 0e97c0ff6..6ed6b8250 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
@@ -20,10 +20,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::stack<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
index e7743ad98..ddf07c424 100644
--- a/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -29,4 +29,6 @@ int main()
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
index 0f8bf035d..df34e4c63 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
@@ -23,10 +23,12 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q(make<std::deque<int> >(5));
     std::stack<int> q2;
     q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
index 16609e983..ad77defe2 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
@@ -29,11 +29,13 @@ make(int n)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::stack<MoveOnly> q2;
     q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
index 605440bc4..1aa6b62c7 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
@@ -36,7 +36,7 @@ void test_return_type() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<std::stack<int> > ();
     test_return_type<std::stack<int, std::vector<int> > > ();
@@ -57,4 +57,6 @@ int main()
 #endif
     assert(q.size() == 3);
     assert(q.top() == Emplaceable(3, 4.5));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp b/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
index afdd996ad..54cd98629 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::stack<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
index 37bf18e2d..a51045e61 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.empty());
@@ -21,4 +21,6 @@ int main()
     assert(!q.empty());
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
index 756eb01c0..95472d7e2 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
@@ -30,4 +30,6 @@ int main()
     assert(q.top() == 1);
     q.pop();
     assert(q.size() == 0);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
index 19615a031..70c085f17 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     q.push(1);
@@ -25,4 +25,6 @@ int main()
     q.push(3);
     assert(q.size() == 3);
     assert(q.top() == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
index f8ad69e99..8969d237b 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q;
     q.push(MoveOnly(1));
@@ -29,4 +29,6 @@ int main()
     q.push(MoveOnly(3));
     assert(q.size() == 3);
     assert(q.top() == MoveOnly(3));
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
index 2e2f945b2..26f2e22ee 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
@@ -13,10 +13,12 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
     q.push(1);
     assert(q.size() == 1);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
index 10c44c0df..88ec3cdfe 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
@@ -23,7 +23,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -32,4 +32,6 @@ int main()
     q1.swap(q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
index f58effe19..6923cc9d2 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
@@ -22,4 +22,6 @@ int main()
     q.push(3);
     int& ir = q.top();
     assert(ir == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
index 348946baa..a5e8c49fa 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@ int main()
     const std::stack<int>& cqr = q;
     const int& cir = cqr.top();
     assert(cir == 3);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
index f343fa109..d5fe97fd5 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
@@ -27,8 +27,10 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 //  LWG#2566 says that the first template param must match the second one's value type
     std::stack<double, std::deque<int>> t;
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp b/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
index 33308c1ad..55fc27f84 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
@@ -44,7 +44,7 @@ struct C
     typedef int size_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_same<std::stack<int>::container_type, std::deque<int> >::value), "");
     static_assert(( std::is_same<std::stack<int, std::vector<int> >::container_type, std::vector<int> >::value), "");
@@ -55,4 +55,6 @@ int main()
     static_assert(( std::uses_allocator<std::stack<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::stack<int, C>, std::allocator<int> >::value), "");
     test t;
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp b/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
index a6e60f1e0..306869f0e 100644
--- a/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
@@ -27,7 +27,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -36,4 +36,6 @@ int main()
     assert(q1 == q1_save);
     assert(q1 != q2);
     assert(q2 == q2_save);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp b/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
index 5494b3dae..3c8734bef 100644
--- a/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
@@ -33,7 +33,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -41,4 +41,6 @@ int main()
     assert(q2 > q1);
     assert(q1 <= q2);
     assert(q2 >= q1);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp b/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
index f8f0ed919..cb1323b58 100644
--- a/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
@@ -24,7 +24,7 @@ make(int n)
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -33,4 +33,6 @@ int main()
     swap(q1, q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp b/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
index 43195ecc8..415ea607e 100644
--- a/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::stack<MoveOnly> C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/container.node/node_handle.pass.cpp b/test/std/containers/container.node/node_handle.pass.cpp
index 37bb73197..40cd8d049 100644
--- a/test/std/containers/container.node/node_handle.pass.cpp
+++ b/test/std/containers/container.node/node_handle.pass.cpp
@@ -128,7 +128,7 @@ void test_insert_return_type()
     test_typedef<typename Container::insert_return_type>();
 }
 
-int main()
+int main(int, char**)
 {
     test_node_handle_operations<std::map<int, int>>();
     test_node_handle_operations_multi<std::multimap<int, int>>();
@@ -143,4 +143,6 @@ int main()
     test_insert_return_type<std::set<int>>();
     test_insert_return_type<std::unordered_map<int, int>>();
     test_insert_return_type<std::unordered_set<int>>();
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp b/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
index 3914affd3..98c291c2e 100644
--- a/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
+++ b/test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
@@ -61,7 +61,7 @@ void test(int expected_num_allocs = 1) {
   }
 }
 
-int main() {
+int main(int, char**) {
   { // test sequence containers
     test<std::vector<int, test_allocator<int> > >();
     test<std::vector<bool, test_allocator<bool> > >();
@@ -102,4 +102,6 @@ int main() {
     test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>,
                                  test_allocator<KV> > >(stored_allocators);
   }
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp b/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
+++ b/test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/containers.general/nothing_to_do.pass.cpp b/test/std/containers/containers.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/containers.general/nothing_to_do.pass.cpp
+++ b/test/std/containers/containers.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/nothing_to_do.pass.cpp b/test/std/containers/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/nothing_to_do.pass.cpp
+++ b/test/std/containers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.cons/deduct.fail.cpp b/test/std/containers/sequences/array/array.cons/deduct.fail.cpp
index fb882eea0..0c0d32f69 100644
--- a/test/std/containers/sequences/array/array.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/array/array.cons/deduct.fail.cpp
@@ -28,9 +28,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::array arr{1,2,3L}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'array'}}
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.cons/deduct.pass.cpp b/test/std/containers/sequences/array/array.cons/deduct.pass.cpp
index fead8cacf..141aafc2a 100644
--- a/test/std/containers/sequences/array/array.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/deduct.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -61,4 +61,6 @@ int main()
     assert(arr[0] == 4.0);
     assert(arr[1] == 5.0);
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.cons/default.pass.cpp b/test/std/containers/sequences/array/array.cons/default.pass.cpp
index 22ed4d832..daa6a5252 100644
--- a/test/std/containers/sequences/array/array.cons/default.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/default.pass.cpp
@@ -21,7 +21,7 @@ struct NoDefault {
   NoDefault(int) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -44,4 +44,6 @@ int main()
       C c2 = {{}};
       assert(c2.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp b/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
index 9d82c93b5..c0e205c83 100644
--- a/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
@@ -32,7 +32,7 @@ struct NoDefault {
   NoDefault(int) {}
 };
 
-int main() {
+int main(int, char**) {
   {
     typedef double T;
     typedef std::array<T, 3> C;
@@ -89,4 +89,6 @@ int main() {
     TEST_NOT_COPY_ASSIGNABLE(C);
   }
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp b/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
index 6a9da4e4f..e85269796 100644
--- a/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         C c = {};
         assert(c.size() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.data/data.pass.cpp b/test/std/containers/sequences/array/array.data/data.pass.cpp
index 36640160e..ce1843eb5 100644
--- a/test/std/containers/sequences/array/array.data/data.pass.cpp
+++ b/test/std/containers/sequences/array/array.data/data.pass.cpp
@@ -25,7 +25,7 @@ struct NoDefault {
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -67,4 +67,6 @@ int main()
       T* p = c.data();
       LIBCPP_ASSERT(p != nullptr);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.data/data_const.pass.cpp b/test/std/containers/sequences/array/array.data/data_const.pass.cpp
index 3b035e67c..32c05d7ef 100644
--- a/test/std/containers/sequences/array/array.data/data_const.pass.cpp
+++ b/test/std/containers/sequences/array/array.data/data_const.pass.cpp
@@ -24,7 +24,7 @@ struct NoDefault {
   NoDefault(int) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -70,4 +70,6 @@ int main()
         static_assert ( *c2.data()  ==  c2[0], "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.fill/fill.fail.cpp b/test/std/containers/sequences/array/array.fill/fill.fail.cpp
index 96641c5cb..9f560dab4 100644
--- a/test/std/containers/sequences/array/array.fill/fill.fail.cpp
+++ b/test/std/containers/sequences/array/array.fill/fill.fail.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
@@ -25,4 +25,6 @@ int main() {
     // expected-error-re@array:* {{static_assert failed {{.*}}"cannot fill zero-sized array of type 'const T'"}}
     c.fill(5.5); // expected-note {{requested here}}
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.fill/fill.pass.cpp b/test/std/containers/sequences/array/array.fill/fill.pass.cpp
index d4dfe9a71..db7363ab9 100644
--- a/test/std/containers/sequences/array/array.fill/fill.pass.cpp
+++ b/test/std/containers/sequences/array/array.fill/fill.pass.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -36,4 +36,6 @@ int main()
         c.fill(5.5);
         assert(c.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.size/size.pass.cpp b/test/std/containers/sequences/array/array.size/size.pass.cpp
index 038df0160..f837bdcf8 100644
--- a/test/std/containers/sequences/array/array.size/size.pass.cpp
+++ b/test/std/containers/sequences/array/array.size/size.pass.cpp
@@ -19,7 +19,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -55,4 +55,6 @@ int main()
         static_assert(c.empty(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.special/swap.pass.cpp b/test/std/containers/sequences/array/array.special/swap.pass.cpp
index f4751cc76..6c9ed957b 100644
--- a/test/std/containers/sequences/array/array.special/swap.pass.cpp
+++ b/test/std/containers/sequences/array/array.special/swap.pass.cpp
@@ -35,7 +35,7 @@ std::false_type can_swap_imp(...);
 template <class Tp>
 struct can_swap : std::is_same<decltype(can_swap_imp<Tp>(0)), void> {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -81,4 +81,6 @@ int main()
         static_assert(!can_swap<C1&>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.swap/swap.fail.cpp b/test/std/containers/sequences/array/array.swap/swap.fail.cpp
index 3e5dc815c..90c149615 100644
--- a/test/std/containers/sequences/array/array.swap/swap.fail.cpp
+++ b/test/std/containers/sequences/array/array.swap/swap.fail.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
@@ -26,4 +26,6 @@ int main() {
     // expected-error-re@array:* {{static_assert failed {{.*}}"cannot swap zero-sized array of type 'const T'"}}
     c.swap(c2); // expected-note {{requested here}}
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.swap/swap.pass.cpp b/test/std/containers/sequences/array/array.swap/swap.pass.cpp
index e23daa88e..aac8a13b2 100644
--- a/test/std/containers/sequences/array/array.swap/swap.pass.cpp
+++ b/test/std/containers/sequences/array/array.swap/swap.pass.cpp
@@ -27,7 +27,7 @@ private:
   NonSwappable& operator=(NonSwappable const&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -89,4 +89,6 @@ int main()
 #endif
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/get.fail.cpp b/test/std/containers/sequences/array/array.tuple/get.fail.cpp
index 25bf53835..7bfe670b2 100644
--- a/test/std/containers/sequences/array/array.tuple/get.fail.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get.fail.cpp
@@ -23,7 +23,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -32,4 +32,6 @@ int main()
         std::get<3>(c) = 5.5; // expected-note {{requested here}}
         // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}} "Index out of bounds in std::get<> (std::array)"}}
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/get.pass.cpp b/test/std/containers/sequences/array/array.tuple/get.pass.cpp
index bbc1c071a..9e94417ac 100644
--- a/test/std/containers/sequences/array/array.tuple/get.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get.pass.cpp
@@ -30,7 +30,7 @@ struct S {
 constexpr std::array<int, 2> getArr () { return { 3, 4 }; }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -55,4 +55,6 @@ int main()
         static_assert(std::get<1>(getArr()) == 4, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp b/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
index 7b964870b..b22a76185 100644
--- a/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
@@ -19,7 +19,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -39,4 +39,6 @@ int main()
         static_assert(std::get<2>(c) == 3.5, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp b/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
index 599e919a3..ce8fc4fd3 100644
--- a/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
@@ -24,7 +24,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -47,4 +47,6 @@ int main()
     static_assert(std::get<2>(std::move(c)) == 3.5, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp b/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
index 77d4633db..d36fcdcc2 100644
--- a/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
@@ -21,7 +21,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -31,4 +31,6 @@ int main()
         T t = std::get<0>(std::move(c));
         assert(*t == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp b/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
index 35cd98647..a4fbd3ab4 100644
--- a/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
+++ b/test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
@@ -23,7 +23,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -31,4 +31,6 @@ int main()
         std::tuple_element<3, C> foo; // expected-note {{requested here}}
         // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}} "Index out of bounds in std::tuple_element<> (std::array)"}}
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp b/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
index 6980838ab..fbf5210f2 100644
--- a/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
@@ -46,8 +46,10 @@ void test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<double>();
     test<int>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp b/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
index e542f34ee..dddcbcaff 100644
--- a/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
+++ b/test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
@@ -33,9 +33,11 @@ void test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<double, 0>();
     test<double, 3>();
     test<double, 5>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp b/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
index ba3c5405d..966e603d1 100644
--- a/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
+++ b/test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
@@ -12,6 +12,8 @@
 
 #include <array>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/at.pass.cpp b/test/std/containers/sequences/array/at.pass.cpp
index b8d1d2b80..0240d5a83 100644
--- a/test/std/containers/sequences/array/at.pass.cpp
+++ b/test/std/containers/sequences/array/at.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool check_idx( size_t idx, double val )
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -116,4 +116,6 @@ int main()
         static_assert (check_idx(2, 3.5), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/begin.pass.cpp b/test/std/containers/sequences/array/begin.pass.cpp
index ce023aa38..7b26d231d 100644
--- a/test/std/containers/sequences/array/begin.pass.cpp
+++ b/test/std/containers/sequences/array/begin.pass.cpp
@@ -24,7 +24,7 @@ struct NoDefault {
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
       LIBCPP_ASSERT(ib != nullptr);
       LIBCPP_ASSERT(ie != nullptr);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/compare.fail.cpp b/test/std/containers/sequences/array/compare.fail.cpp
index 1710fe788..47859ad49 100644
--- a/test/std/containers/sequences/array/compare.fail.cpp
+++ b/test/std/containers/sequences/array/compare.fail.cpp
@@ -41,7 +41,7 @@ void test_compare(const Array& LHS, const Array& RHS) {
 
 template <int Dummy> struct NoCompare {};
 
-int main()
+int main(int, char**)
 {
   {
     typedef NoCompare<0> T;
@@ -67,4 +67,6 @@ int main()
     TEST_IGNORE_NODISCARD (c1 == c1);
     TEST_IGNORE_NODISCARD (c1 < c1);
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/compare.pass.cpp b/test/std/containers/sequences/array/compare.pass.cpp
index 56eabbd00..c05dd1940 100644
--- a/test/std/containers/sequences/array/compare.pass.cpp
+++ b/test/std/containers/sequences/array/compare.pass.cpp
@@ -28,7 +28,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
   {
     typedef int T;
@@ -58,4 +58,6 @@ int main()
   static_assert(testComparisons6(a2, a1, false, false), "");
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/contiguous.pass.cpp b/test/std/containers/sequences/array/contiguous.pass.cpp
index ce953794a..e0ab5b61c 100644
--- a/test/std/containers/sequences/array/contiguous.pass.cpp
+++ b/test/std/containers/sequences/array/contiguous.pass.cpp
@@ -20,11 +20,13 @@ void test_contiguous ( const C &c )
         assert ( *(c.begin() + i) == *(std::addressof(*c.begin()) + i));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         test_contiguous (C());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/empty.fail.cpp b/test/std/containers/sequences/array/empty.fail.cpp
index 424f71541..3bbb3c8e1 100644
--- a/test/std/containers/sequences/array/empty.fail.cpp
+++ b/test/std/containers/sequences/array/empty.fail.cpp
@@ -20,11 +20,13 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
 
     std::array<int, 1> c;
     c.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::array<int, 0> c0;
     c0.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/empty.pass.cpp b/test/std/containers/sequences/array/empty.pass.cpp
index 485806947..a17aa50c5 100644
--- a/test/std/containers/sequences/array/empty.pass.cpp
+++ b/test/std/containers/sequences/array/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::array<int, 2> C;
@@ -32,4 +32,6 @@ int main()
     ASSERT_NOEXCEPT(c.empty());
     assert( c.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/front_back.pass.cpp b/test/std/containers/sequences/array/front_back.pass.cpp
index 13368683a..1a714369f 100644
--- a/test/std/containers/sequences/array/front_back.pass.cpp
+++ b/test/std/containers/sequences/array/front_back.pass.cpp
@@ -36,7 +36,7 @@ constexpr bool check_back( double val )
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -115,4 +115,6 @@ int main()
         static_assert (check_back (3.5), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/indexing.pass.cpp b/test/std/containers/sequences/array/indexing.pass.cpp
index a33a597fc..bf55711a1 100644
--- a/test/std/containers/sequences/array/indexing.pass.cpp
+++ b/test/std/containers/sequences/array/indexing.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool check_idx( size_t idx, double val )
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -104,4 +104,6 @@ int main()
         static_assert (check_idx(2, 3.5), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/iterators.pass.cpp b/test/std/containers/sequences/array/iterators.pass.cpp
index 7e4c9b756..71fad183f 100644
--- a/test/std/containers/sequences/array/iterators.pass.cpp
+++ b/test/std/containers/sequences/array/iterators.pass.cpp
@@ -20,7 +20,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::array<int, 5> C;
@@ -141,4 +141,6 @@ int main()
         static_assert ( *std::crbegin(c) == 4, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/max_size.pass.cpp b/test/std/containers/sequences/array/max_size.pass.cpp
index 1f3ec0472..a0b77392e 100644
--- a/test/std/containers/sequences/array/max_size.pass.cpp
+++ b/test/std/containers/sequences/array/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::array<int, 2> C;
@@ -32,4 +32,6 @@ int main()
     ASSERT_NOEXCEPT(c.max_size());
     assert(c.max_size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/size_and_alignment.pass.cpp b/test/std/containers/sequences/array/size_and_alignment.pass.cpp
index c57740bca..f585da6ce 100644
--- a/test/std/containers/sequences/array/size_and_alignment.pass.cpp
+++ b/test/std/containers/sequences/array/size_and_alignment.pass.cpp
@@ -57,7 +57,9 @@ struct TEST_ALIGNAS(TEST_ALIGNOF(std::max_align_t) * 2) TestType2 {
   char data[1000];
 };
 
-int main() {
+//static_assert(sizeof(void*) == 4, "");
+
+int main(int, char**) {
   test_type<char>();
   test_type<int>();
   test_type<double>();
@@ -65,4 +67,6 @@ int main() {
   test_type<std::max_align_t>();
   test_type<TestType1>();
   test_type<TestType2>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/array/types.pass.cpp b/test/std/containers/sequences/array/types.pass.cpp
index e76c06e6d..f86e008d2 100644
--- a/test/std/containers/sequences/array/types.pass.cpp
+++ b/test/std/containers/sequences/array/types.pass.cpp
@@ -47,7 +47,7 @@ void test_iterators() {
     static_assert((std::is_same<typename CItT::difference_type, typename C::difference_type>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -93,4 +93,6 @@ int main()
         static_assert((std::is_same<typename C::difference_type,
             typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp b/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
index 769aa9ec1..287faf75e 100644
--- a/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <deque>
 
-int main()
+int main(int, char**)
 {
     std::deque<int, std::allocator<long> > d;
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
index b63784312..86c518450 100644
--- a/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
@@ -47,7 +47,7 @@ make(int size, int start = 0 )
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::deque<int> c = make<std::deque<int> >(10);
@@ -87,4 +87,6 @@ int main()
         assert(c.back() == 9);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp b/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
index 701e31897..79e4b30b2 100644
--- a/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::deque<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
index 7adf6656a..388594110 100644
--- a/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::deque<int> C;
@@ -42,4 +42,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
index d5b3cc521..230a46519 100644
--- a/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::deque<int, A> C;
@@ -43,4 +43,6 @@ int main() {
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
index 6ef329ee6..916159221 100644
--- a/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
@@ -65,7 +65,7 @@ testN(int start, int N, int M)
     test(c1, M);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -85,4 +85,6 @@ int main()
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
index 02910d8bf..876ff2fe5 100644
--- a/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
@@ -65,7 +65,7 @@ testN(int start, int N, int M)
     test(c1, M, -10);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -85,4 +85,6 @@ int main()
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
index e4f0e2bd0..bde2eaaaa 100644
--- a/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
@@ -55,7 +55,7 @@ testN(int start, int N)
     test(c1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -73,4 +73,6 @@ int main()
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
index 2b89c0490..c70abe421 100644
--- a/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::deque<int> C;
@@ -58,4 +58,6 @@ int main()
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
index 4dcea9782..e2700b958 100644
--- a/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
@@ -26,7 +26,7 @@ test(const Allocator& a)
     assert(d.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<int>(std::allocator<int>());
     test<NotConstructible>(test_allocator<NotConstructible>(3));
@@ -36,4 +36,6 @@ int main()
     test<int>(explicit_allocator<int>());
     test<NotConstructible>(explicit_allocator<NotConstructible>{});
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
index 5441583fa..edca369a5 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d;
@@ -37,4 +37,6 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
index 6b3b3f19a..d59943574 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -149,7 +149,9 @@ void test_emplacable_concept() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
index ba18ab24e..2875a1776 100644
--- a/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
@@ -60,7 +60,7 @@ testN(int start, int N, int M)
     test(c1, M, -10);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -80,4 +80,6 @@ int main()
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp b/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
index bb5bb1393..2d42ee38a 100644
--- a/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
@@ -25,7 +25,7 @@ test(const C& x)
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -57,4 +57,6 @@ int main()
         assert(v2.get_allocator() == v.get_allocator());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
index 138e6bdc7..4334fd6a5 100644
--- a/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
@@ -25,7 +25,7 @@ test(const C& x, const typename C::allocator_type& a)
     assert(c.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -47,4 +47,6 @@ int main()
                                                           min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp b/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
index 3180384aa..99bf89c79 100644
--- a/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -38,4 +38,6 @@ int main()
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp b/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
index b349819cc..ac0861381 100644
--- a/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -94,4 +94,6 @@ int main()
     static_assert(std::is_same_v<decltype(deq)::allocator_type, std::allocator<long double>>, "");
     assert(deq.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/default.pass.cpp b/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
index bb84f05f4..f132eb5be 100644
--- a/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/default.pass.cpp
@@ -29,7 +29,7 @@ test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int, std::allocator<int> >();
     test<NotConstructible, limited_allocator<NotConstructible, 1> >();
@@ -37,4 +37,6 @@ int main()
     test<int, min_allocator<int> >();
     test<NotConstructible, min_allocator<NotConstructible> >();
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
index fea4799d5..abc3de7db 100644
--- a/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@ int main()
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
index 3dcc15045..7e09148b4 100644
--- a/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::deque<MoveOnly> C;
@@ -47,4 +47,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
index b76d0cca5..02cbadd6c 100644
--- a/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d = {3, 4, 5, 6};
@@ -35,4 +35,6 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
index e412e94e7..1450c978b 100644
--- a/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
@@ -38,4 +38,6 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
index 6c68cd090..214ac8303 100644
--- a/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -105,7 +105,9 @@ void test_emplacable_concept() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
index c6391620b..c72f73a9a 100644
--- a/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -96,7 +96,9 @@ void test_emplacable_concept() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/move.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
index ee628c6aa..b8fdc9892 100644
--- a/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -68,4 +68,6 @@ int main()
         assert(c1.size() == 0);
         assert(c3.get_allocator() == c1.get_allocator());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
index 54ce39d7e..68dd99f10 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -82,4 +82,6 @@ int main()
         assert(c3.get_allocator() == A());
         LIBCPP_ASSERT(c1.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
index 325f24c80..5fcfbb8d9 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -85,4 +85,6 @@ int main()
         assert(c1.size() == 0);
         assert(c3.get_allocator() == A());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
index 3facd3084..1d86c14aa 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
@@ -31,7 +31,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::deque<MoveOnly> C;
@@ -51,4 +51,6 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
index b5d3331f4..8b4b4fb1f 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@ int main()
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp b/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
index 22f015950..c26ddec0c 100644
--- a/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
@@ -24,7 +24,7 @@ test(const C& x)
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -59,4 +59,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
index 140bb9c76..5f4150201 100644
--- a/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d;
@@ -37,4 +37,6 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/size.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
index fe378e58f..b69d2bb59 100644
--- a/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
@@ -86,7 +86,7 @@ test(unsigned n)
     test2<T, Allocator> ( n );
 }
 
-int main()
+int main(int, char**)
 {
     test<DefaultOnly, std::allocator<DefaultOnly> >(0);
     test<DefaultOnly, std::allocator<DefaultOnly> >(1);
@@ -113,4 +113,6 @@ int main()
     test3<int, min_allocator<int>> (3);
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
index 8926a8793..8c432182a 100644
--- a/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
@@ -30,7 +30,7 @@ test(unsigned n, const T& x)
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<int, std::allocator<int> >(0, 5);
     test<int, std::allocator<int> >(1, 10);
@@ -48,4 +48,6 @@ int main()
 #if TEST_STD_VER >= 11
     test<int, min_allocator<int> >(4095, 90);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
index 80218de73..d7e4b3df9 100644
--- a/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
@@ -30,7 +30,7 @@ test(unsigned n, const T& x, const Allocator& a)
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     std::allocator<int> a;
@@ -64,4 +64,6 @@ int main()
     test(4097, 157, a);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp b/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
index 5af8faef4..2293ef205 100644
--- a/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::deque<long>>();
     test<std::deque<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp b/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
index 181c73686..e0828a3fa 100644
--- a/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::deque<long>>();
     test<std::deque<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
index 8cfa82406..becc36878 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
@@ -17,7 +17,7 @@
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef NotConstructible T;
@@ -63,4 +63,6 @@ int main()
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
index 78278df32..f4713dfdf 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
@@ -86,7 +86,7 @@ testN(int start, int N)
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -102,4 +102,6 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable, min_allocator<Emplaceable>> >(rng[i], rng[j]);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
index 835a47a5e..ae04c7d17 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
@@ -74,7 +74,7 @@ testN(int start, int N)
     test(c1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -101,4 +101,6 @@ int main()
         c.emplace_front(1, 2, 3);
         assert(c.size() == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
index 7f0298cdf..43d6c36d2 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
@@ -75,7 +75,7 @@ testN(int start, int N)
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -102,4 +102,6 @@ int main()
         c.emplace_front(1, 2, 3);
         assert(c.size() == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
index 3a055df9f..54395114a 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
@@ -54,7 +54,7 @@ void del_at_end(C c)
     assert(&*it2 == &*it4);
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -66,4 +66,6 @@ int main()
         del_at_end(queue);
         queue.pop_back();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
index 79cb562c1..d8db68368 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
@@ -88,7 +88,7 @@ testN(int start, int N)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -121,4 +121,6 @@ int main()
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
index fd08b6afe..3a8a06d58 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
@@ -59,7 +59,7 @@ void del_at_end(C c, size_t num)
 }
 
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -74,4 +74,6 @@ int main()
         }
         queue.pop_back();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
index c81d9a8bb..c738748a6 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
@@ -95,7 +95,7 @@ testN(int start, int N)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -127,4 +127,6 @@ int main()
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
index f14da8a81..e0da02f7e 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d(10, 1);
@@ -59,4 +59,6 @@ int main()
     assert(d[12] == 1);
     assert(d[13] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
index cb36aa280..9a5f05476 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
@@ -259,7 +259,7 @@ test_move()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -285,4 +285,6 @@ int main()
     test_move<std::deque<MoveOnly, min_allocator<MoveOnly> > >();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
index a9f242706..eec8e0a49 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
@@ -91,7 +91,7 @@ testN(int start, int N)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -107,4 +107,6 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[i], rng[j]);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
index ced0e360b..0b95c8fc5 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
@@ -132,7 +132,7 @@ self_reference_test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -154,4 +154,6 @@ int main()
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
index 2e16c342a..8dc0b50b5 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
@@ -114,7 +114,7 @@ self_reference_test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -134,4 +134,6 @@ int main()
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
index 74c48d326..7b5427b83 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
@@ -34,7 +34,7 @@ void test(C c)
     assert(&*it2 == &*it4);
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -45,4 +45,6 @@ int main()
         test(queue);
         queue.pop_back();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
index 1eee65186..b0315eb54 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
@@ -63,7 +63,7 @@ testN(int start, int N)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -81,4 +81,6 @@ int main()
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
index e773debde..3ff1b5b9f 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
@@ -34,7 +34,7 @@ void test(C c)
     assert(&*it2 == &*it4);
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -45,4 +45,6 @@ int main()
         test(queue);
         queue.pop_back();
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
index 672187380..9d25d1684 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
@@ -63,7 +63,7 @@ testN(int start, int N)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -81,4 +81,6 @@ int main()
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
index be2d72c53..d0a73c37f 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
@@ -53,7 +53,7 @@ void test(int size)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
@@ -69,4 +69,6 @@ int main()
         test<std::deque<int, min_allocator<int>> >(rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
index 4bd62b109..d4c46f0bc 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
@@ -64,7 +64,7 @@ CMyClass::~CMyClass() {
 
 bool operator==(const CMyClass &lhs, const CMyClass &rhs) { return lhs.equal(rhs); }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance(42);
     {
@@ -98,4 +98,6 @@ int main()
         assert(vec==vec2);
     }
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
index aa9366956..293544681 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
@@ -58,7 +58,7 @@ void test(int size)
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
@@ -72,4 +72,6 @@ int main()
     for (int j = 0; j < N; ++j)
         test<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[j]);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
index 7e4f7151c..dee483c79 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
@@ -62,7 +62,7 @@ testN(int start, int N)
     test(c1, -10);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -80,4 +80,6 @@ int main()
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
index a6a5200e9..103f2c41d 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
@@ -64,7 +64,7 @@ CMyClass::~CMyClass() {
 
 bool operator==(const CMyClass &lhs, const CMyClass &rhs) { return lhs.equal(rhs); }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance(42);
     {
@@ -98,4 +98,6 @@ int main()
         assert(vec==vec2);
     }
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
index 3ffde9bf3..7a66554d1 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
@@ -67,7 +67,7 @@ testN(int start, int N)
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@ int main()
         for (int j = 0; j < N; ++j)
             testN<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[i], rng[j]);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.special/copy.pass.cpp b/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
index f6ee7737d..f861c424a 100644
--- a/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
@@ -66,7 +66,7 @@ void testN(int start, int N)
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -84,4 +84,6 @@ int main()
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp b/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
index 2e51d13ce..b5225ae71 100644
--- a/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
@@ -65,7 +65,7 @@ void testN(int start, int N)
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@ int main()
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.special/move.pass.cpp b/test/std/containers/sequences/deque/deque.special/move.pass.cpp
index d26132b3f..d1c2a3d72 100644
--- a/test/std/containers/sequences/deque/deque.special/move.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/move.pass.cpp
@@ -65,7 +65,7 @@ void testN(int start, int N)
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@ int main()
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp b/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
index 0f3ab067f..9193609d2 100644
--- a/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
@@ -65,7 +65,7 @@ void testN(int start, int N)
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@ int main()
             testN<std::deque<int, min_allocator<int> > >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.special/swap.pass.cpp b/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
index 56310b80c..33910e419 100644
--- a/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/swap.pass.cpp
@@ -50,7 +50,7 @@ void testN(int start, int N, int M)
     assert(c2 == c1_save);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -106,4 +106,6 @@ int main()
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
index 7820480da..edbe21128 100644
--- a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
@@ -52,7 +52,7 @@ struct some_alloc2
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::deque<MoveOnly> C;
@@ -85,4 +85,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/iterators.pass.cpp b/test/std/containers/sequences/deque/iterators.pass.cpp
index 9fe9326ec..1f06ffde4 100644
--- a/test/std/containers/sequences/deque/iterators.pass.cpp
+++ b/test/std/containers/sequences/deque/iterators.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::deque<int> C;
@@ -76,4 +76,6 @@ int main()
 //         assert ( ii1 != c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/deque/types.pass.cpp b/test/std/containers/sequences/deque/types.pass.cpp
index 131040092..cfab930f3 100644
--- a/test/std/containers/sequences/deque/types.pass.cpp
+++ b/test/std/containers/sequences/deque/types.pass.cpp
@@ -71,7 +71,7 @@ test()
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<int, test_allocator<int> >();
     test<int*, std::allocator<int*> >();
@@ -100,4 +100,6 @@ int main()
             typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp b/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
index 6973d9aee..42fb8da91 100644
--- a/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <forward_list>
 
-int main()
+int main(int, char**)
 {
     std::forward_list<int, std::allocator<long> > fl;
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/empty.fail.cpp b/test/std/containers/sequences/forwardlist/empty.fail.cpp
index effcc2733..2ca3e024e 100644
--- a/test/std/containers/sequences/forwardlist/empty.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::forward_list<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/empty.pass.cpp b/test/std/containers/sequences/forwardlist/empty.pass.cpp
index 6597c66ea..727904c98 100644
--- a/test/std/containers/sequences/forwardlist/empty.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::forward_list<int> C;
@@ -42,4 +42,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
index 26bbdb61e..2509e9b2c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -57,4 +57,6 @@ int main()
         assert(*c.begin() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
index 205728658..bf43ee82c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "../../../NotConstructible.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<NotConstructible> A;
@@ -26,4 +26,6 @@ int main()
         assert(c.get_allocator() == A(12));
         assert(c.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
index b70b4e8a2..c362e2051 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
@@ -17,7 +17,7 @@
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<NotConstructible> A;
@@ -45,4 +45,6 @@ int main()
         assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
index 05a74d50d..e40d405c9 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -142,4 +142,6 @@ int main()
         assert(c1.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
index 20ed6c51a..40405dd2e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@ int main()
             assert(*i == 10+n);
         assert(n == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
index 24feee382..36e4ea0ca 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -193,4 +193,6 @@ int main()
         assert(c1.get_allocator() == A());
         assert(c0.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
index 42f0a43b9..14c098b66 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@ int main()
             assert(*i == 10+n);
         assert(n == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
index 098702b44..c0b934445 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -74,4 +74,6 @@ int main()
         assert(n == 4);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
index ec8aadf38..ea4cc811e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@ int main()
         assert(n == 4);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
index 551eebb44..681629a2c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@ int main()
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
index bfcb2b490..9788ca5ff 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -63,4 +63,6 @@ int main()
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
index 9c91a031f..cc146316a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -38,4 +38,6 @@ int main()
 //      forward_list<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
index e4599d469..fd49de581 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -99,4 +99,6 @@ int main()
     static_assert(std::is_same_v<decltype(fwl)::allocator_type, std::allocator<long double>>, "");
     assert(std::distance(fwl.begin(), fwl.end()) == 0); // no size for forward_list
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
index 27eb1577c..1694faf46 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@ int main()
         assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
index 992636916..f9363feb6 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@ int main()
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
index ab61b04f9..98b120f53 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
@@ -19,6 +19,8 @@ struct X
     std::forward_list<X> q;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
index ce3d0f437..ba8799645 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::forward_list<MoveOnly> C;
@@ -47,4 +47,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
index ac4bcf4a5..fda636073 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@ int main()
             assert(*i == n);
         assert(n == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
index 05a318778..cdef7c07e 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@ int main()
         assert(n == 10);
         assert(c.get_allocator() == A());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
index 428fa04f1..eedec3487 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -67,4 +67,6 @@ int main()
         assert(c0.empty());
         assert(c.get_allocator() == A());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
index 9337b9b05..7db6a41e8 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -67,4 +67,6 @@ int main()
         assert(c0.empty());
         assert(c.get_allocator() == A());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
index 502ca930e..486c124af 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
@@ -31,7 +31,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::forward_list<MoveOnly> C;
@@ -51,4 +51,6 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
index ddd3cfe73..5717bb891 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@ int main()
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
index fb0ec74d6..ce9cd59d1 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -44,4 +44,6 @@ int main()
         assert(n == std::end(t) - std::begin(t));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
index 30fe467fd..1a85d3fee 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -50,4 +50,6 @@ int main()
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
index 7514d263e..ca3931d10 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
@@ -33,7 +33,7 @@ void check_allocator(unsigned n, Allocator const &alloc = Allocator())
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     { // test that the ctor is explicit
       typedef std::forward_list<DefaultOnly> C;
@@ -70,4 +70,6 @@ int main()
         check_allocator<T, min_allocator<T>> ( 3 );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
index eee26298e..e3f247202 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -41,4 +41,6 @@ int main()
         assert(n == N);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
index 26b3f8c6f..cc5394f5a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -46,4 +46,6 @@ int main()
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
index 53e99b48c..68a26fbc7 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::forward_list<int>>();
     test<std::forward_list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::forward_list<long>>();
     test<std::forward_list<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
index e3e857540..b2106b8c8 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::forward_list<int>>();
     test<std::forward_list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::forward_list<long>>();
     test<std::forward_list<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
index 726051b8e..638a78327 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -100,4 +100,6 @@ int main()
         assert(std::distance(i, c.end()) == 11);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
index 25c2c312b..e5441109b 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -142,4 +142,6 @@ int main()
 //         assert ( ii1 != c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
index 5f7ac62c4..8ed29ec5a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
@@ -17,7 +17,7 @@
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef NotConstructible T;
@@ -63,4 +63,6 @@ int main()
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
index 70e7d248f..f25812398 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef Emplaceable T;
@@ -83,4 +83,6 @@ int main()
         assert(*next(c.begin(), 3) == Emplaceable(2, 3.5));
         assert(distance(c.begin(), c.end()) == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
index 121e0178c..1669e0c5c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
@@ -21,7 +21,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef Emplaceable T;
@@ -67,4 +67,6 @@ int main()
         assert(*next(c.begin()) == Emplaceable());
         assert(distance(c.begin(), c.end()) == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
index 419ce6891..0a431a896 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -151,4 +151,6 @@ int main()
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
index 563be1739..59e687f6c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -93,4 +93,6 @@ int main()
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
index bfc8c04f1..3ba4f9e23 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -83,4 +83,6 @@ int main()
         assert(distance(c.begin(), c.end()) == 4);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
index 1782bc7fd..be5c6e517 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -69,4 +69,6 @@ int main()
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
index 8ad42aced..4cbc92edd 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -76,4 +76,6 @@ int main()
         assert(*next(c.begin(), 4) == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
index 2aa254bbf..2495a707a 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -84,4 +84,6 @@ int main()
         assert(*next(c.begin(), 3) == 2);
         assert(distance(c.begin(), c.end()) == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
index e1927945a..7898fea92 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -69,4 +69,6 @@ int main()
         assert(*next(c.begin(), 4) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
index 40b092e76..d28f10e81 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
@@ -16,7 +16,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -70,4 +70,6 @@ int main()
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
index 15e3bfbc1..192227ee2 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -43,4 +43,6 @@ int main()
         assert(distance(c.begin(), c.end()) == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
index 3015abb76..8b122f1f9 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
@@ -57,7 +57,7 @@ CMyClass::~CMyClass() {
     assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance;
     std::forward_list<CMyClass> vec;
@@ -70,4 +70,6 @@ int main()
     }
     catch (...) {
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
index e768cd0ae..268101671 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -44,4 +44,6 @@ int main()
         assert(*next(c.begin()) == 1);
         assert(distance(c.begin(), c.end()) == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
index b79e4fd36..ed2de9800 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
@@ -16,7 +16,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef DefaultOnly T;
@@ -110,4 +110,6 @@ int main()
         assert(*next(c.begin(), 5) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
index 30f99ab96..f6f4027e0 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
@@ -21,7 +21,7 @@
 #include "container_test_types.h"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -98,4 +98,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
index c2e32a754..5a55ae963 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -44,4 +44,6 @@ int main()
         assert(c1 == c3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
index 6656f9191..3de61a37f 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -45,4 +45,6 @@ int main()
         assert(c1 == c3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
index fec75668a..ca3ec253d 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
@@ -27,7 +27,7 @@ struct S {
     };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -151,4 +151,6 @@ int main()
         assert(c1 == c2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
index 45a12e7e8..1b18337bc 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
@@ -24,7 +24,7 @@ bool g(int i)
     return i < 3;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -152,4 +152,6 @@ int main()
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
index e9fe3cae6..82b6813ff 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
@@ -30,7 +30,7 @@ void test(int N)
         assert(*j == i);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int> >(i);
@@ -38,4 +38,6 @@ int main()
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
index 239e5f129..c76fe03ec 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
@@ -38,7 +38,7 @@ void test(int N)
         assert(*j == i);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
@@ -46,4 +46,6 @@ int main()
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
index d7e127bf4..971508ac4 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
@@ -39,7 +39,7 @@ void test(int N)
         assert(*j == N-1-i);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
@@ -47,4 +47,6 @@ int main()
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
index 6b57b3189..e883aee2c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
@@ -38,7 +38,7 @@ testd(const C& c, int p, int l)
     assert(distance(c.begin(), c.end()) == size_t1 + l);
 }
 
-int main()
+int main(int, char**)
 {
     {
     // splicing different containers
@@ -72,4 +72,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
index a192627d8..87b2f60e1 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
@@ -75,7 +75,7 @@ tests(const C& c, int p, int f)
     assert(distance(c.begin(), c.end()) == size_t1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     // splicing different containers
@@ -137,4 +137,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
index c836a8bfe..32050076c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
@@ -75,7 +75,7 @@ tests(const C& c, int p, int f, int l)
     assert(distance(c.begin(), c.end()) == size_t1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     // splicing different containers
@@ -165,4 +165,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
index ccb0f9a86..07a4eae97 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -116,4 +116,6 @@ int main()
         assert(c1 == c2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
index 1d4a9a0f3..87db88080 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
@@ -21,7 +21,7 @@ bool g(int x, int y)
     return x == y;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -121,4 +121,6 @@ int main()
         assert(c1 == c2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/equal.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/equal.pass.cpp
index 9f01fed66..a727487ed 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/equal.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/equal.pass.cpp
@@ -47,7 +47,7 @@ void test(int N, int M)
     }
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         for (int j = 0; j < 10; ++j)
@@ -57,4 +57,6 @@ int main()
         for (int j = 0; j < 10; ++j)
             test<std::forward_list<int, min_allocator<int>> >(i, j);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
index 242a00bd8..5e0438c62 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -256,4 +256,6 @@ int main()
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
index 44820d9d3..5b9b590d5 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -257,4 +257,6 @@ int main()
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/relational.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/relational.pass.cpp
index e65e064ff..29a180a96 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/relational.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/relational.pass.cpp
@@ -52,7 +52,7 @@ void test(int N, int M)
         assert(c1 > c2);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         for (int j = 0; j < 10; ++j)
@@ -62,4 +62,6 @@ int main()
         for (int j = 0; j < 10; ++j)
             test<std::forward_list<int, min_allocator<int>> >(i, j);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
index ae48d1a4b..624795495 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
@@ -53,7 +53,7 @@ struct some_alloc2
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::forward_list<MoveOnly> C;
@@ -85,4 +85,6 @@ int main()
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/incomplete.pass.cpp b/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
index fd789b8c8..2bdfad777 100644
--- a/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/incomplete.pass.cpp
@@ -33,7 +33,7 @@ struct B {
 };
 #endif
 
-int main()
+int main(int, char**)
 {
   {
     A a;
@@ -49,4 +49,6 @@ int main()
     b.it2 = b.d.cbefore_begin();
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/max_size.pass.cpp b/test/std/containers/sequences/forwardlist/max_size.pass.cpp
index 6b93a3db6..08d21d641 100644
--- a/test/std/containers/sequences/forwardlist/max_size.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -44,4 +44,6 @@ int main()
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/forwardlist/types.pass.cpp b/test/std/containers/sequences/forwardlist/types.pass.cpp
index ff6c10e46..01a7db039 100644
--- a/test/std/containers/sequences/forwardlist/types.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/types.pass.cpp
@@ -31,7 +31,7 @@
 
 struct A { std::forward_list<A> v; }; // incomplete type support
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::forward_list<char> C;
@@ -72,4 +72,6 @@ int main()
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/allocator_mismatch.fail.cpp b/test/std/containers/sequences/list/allocator_mismatch.fail.cpp
index 002954b44..39dcde477 100644
--- a/test/std/containers/sequences/list/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/list/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <list>
 
-int main()
+int main(int, char**)
 {
     std::list<int, std::allocator<long> > l;
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/incomplete_type.pass.cpp b/test/std/containers/sequences/list/incomplete_type.pass.cpp
index 04b04d0bc..e68f06176 100644
--- a/test/std/containers/sequences/list/incomplete_type.pass.cpp
+++ b/test/std/containers/sequences/list/incomplete_type.pass.cpp
@@ -21,6 +21,8 @@ struct A {
     std::list<A>::const_reverse_iterator crit;
 };
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/iterators.pass.cpp b/test/std/containers/sequences/list/iterators.pass.cpp
index 89cc3932d..0fe92dfba 100644
--- a/test/std/containers/sequences/list/iterators.pass.cpp
+++ b/test/std/containers/sequences/list/iterators.pass.cpp
@@ -28,7 +28,7 @@ struct A
     int second;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -152,4 +152,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.capacity/empty.fail.cpp b/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
index 99325fcb6..0cbaa464d 100644
--- a/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
+++ b/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::list<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.capacity/empty.pass.cpp b/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
index 27bd73e88..7619ec508 100644
--- a/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::list<int> C;
@@ -42,4 +42,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp b/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
index e3da37d73..8560a6a87 100644
--- a/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::list<int, A> C;
@@ -43,4 +43,6 @@ int main() {
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
index 04476900d..3c9e240d7 100644
--- a/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
@@ -15,7 +15,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(5, 2);
@@ -77,4 +77,6 @@ int main()
     }
 #endif  // __LIBCPP_MOVE
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
index 404bb0c1b..db1c1419c 100644
--- a/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
@@ -15,7 +15,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<double> l(5, 2);
@@ -49,4 +49,6 @@ int main()
         assert(l.back() == 3.5);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.capacity/size.pass.cpp b/test/std/containers/sequences/list/list.capacity/size.pass.cpp
index b28b6572f..d4801e76c 100644
--- a/test/std/containers/sequences/list/list.capacity/size.pass.cpp
+++ b/test/std/containers/sequences/list/list.capacity/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::list<int> C;
@@ -58,4 +58,6 @@ int main()
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
index c4493cac7..91ac1cfa6 100644
--- a/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
@@ -40,4 +40,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
index 80d5ad074..54c91ae4a 100644
--- a/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d;
@@ -39,4 +39,6 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
index 7400ba5ca..1e826ed91 100644
--- a/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -76,4 +76,6 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/copy.pass.cpp b/test/std/containers/sequences/list/list.cons/copy.pass.cpp
index 68b2e9d16..153cd2dbc 100644
--- a/test/std/containers/sequences/list/list.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/copy.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(3, 2);
@@ -50,4 +50,6 @@ int main()
         assert(l2.get_allocator() == l.get_allocator());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
index b722c40e6..14e958502 100644
--- a/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
@@ -38,4 +38,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/deduct.fail.cpp b/test/std/containers/sequences/list/list.cons/deduct.fail.cpp
index 6d9833b5f..36982263d 100644
--- a/test/std/containers/sequences/list/list.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/list/list.cons/deduct.fail.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -38,4 +38,6 @@ int main()
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/deduct.pass.cpp b/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
index 20c017500..03d3f3818 100644
--- a/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -99,4 +99,6 @@ int main()
     static_assert(std::is_same_v<decltype(lst)::allocator_type, std::allocator<long double>>, "");
     assert(lst.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/default.pass.cpp b/test/std/containers/sequences/list/list.cons/default.pass.cpp
index ffbfa0b21..348390c45 100644
--- a/test/std/containers/sequences/list/list.cons/default.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default.pass.cpp
@@ -15,7 +15,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l;
@@ -64,4 +64,6 @@ int main()
         assert(std::distance(l.begin(), l.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
index b41f7320d..93951e963 100644
--- a/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@ int main()
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
index 1596a4e44..2e0b5203b 100644
--- a/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l;
@@ -44,4 +44,6 @@ int main()
         assert(std::distance(l.begin(), l.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
index 64894dc38..62af49e63 100644
--- a/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::list<MoveOnly> C;
@@ -47,4 +47,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
index 61a277395..bd4ffeb13 100644
--- a/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d = {3, 4, 5, 6};
@@ -37,4 +37,6 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
index ec560ef8d..f6eca2112 100644
--- a/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
@@ -40,4 +40,6 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
index ef6e11b25..f7491f450 100644
--- a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -244,10 +244,12 @@ void test_ctor_under_alloc_with_alloc() {
 
 
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
   test_emplacable_concept_with_alloc();
   test_ctor_under_alloc();
   test_ctor_under_alloc_with_alloc();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/move.pass.cpp b/test/std/containers/sequences/list/list.cons/move.pass.cpp
index 9ad55ecdb..a79a37232 100644
--- a/test/std/containers/sequences/list/list.cons/move.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -59,4 +59,6 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
index 80ef7cdde..d18ea2c4a 100644
--- a/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -72,4 +72,6 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == min_allocator<MoveOnly>());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
index b12e3d9e3..c6c714595 100644
--- a/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
@@ -31,7 +31,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::list<MoveOnly> C;
@@ -51,4 +51,6 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
index 1b40bbdff..43abd019a 100644
--- a/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@ int main()
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
index b0d6a374e..58ea88f43 100644
--- a/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d;
@@ -38,4 +38,6 @@ int main()
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/size_type.pass.cpp b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
index f11d617e1..ef365d09f 100644
--- a/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp
@@ -37,7 +37,7 @@ test3(unsigned n, Allocator const &alloc = Allocator())
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(3);
@@ -100,4 +100,6 @@ int main()
         assert(std::distance(l.begin(), l.end()) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
index 25b3425ab..282de37bb 100644
--- a/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(3, 2);
@@ -76,4 +76,6 @@ int main()
         assert(*i == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.erasure/erase.pass.cpp b/test/std/containers/sequences/list/list.erasure/erase.pass.cpp
index 6f0b5fc89..9c03c7282 100644
--- a/test/std/containers/sequences/list/list.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/list/list.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int>>();
     test<std::list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::list<long>>();
     test<std::list<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp b/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
index 152f66633..f25d3e830 100644
--- a/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int>>();
     test<std::list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::list<long>>();
     test<std::list<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
index ba9e413e5..0afd0a548 100644
--- a/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -34,4 +34,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
index 5183cd9a7..642e84342 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
@@ -34,7 +34,7 @@ public:
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::list<A> c;
@@ -63,4 +63,6 @@ int main()
     assert(c.back().getd() == 4.5);
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
index ca428ec65..b7eaa7047 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
@@ -34,7 +34,7 @@ public:
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::list<A> c;
@@ -84,4 +84,6 @@ int main()
     assert(c.back().geti() == 3);
     assert(c.back().getd() == 4.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
index 25d7eb37d..eece4186c 100644
--- a/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
@@ -33,7 +33,7 @@ public:
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::list<A> c;
@@ -84,4 +84,6 @@ int main()
     assert(c.back().geti() == 2);
     assert(c.back().getd() == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
index 824c36806..87486b616 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -61,4 +61,6 @@ int main()
     assert(distance(l1.begin(), l1.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
index 8166efbd3..1df39913c 100644
--- a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     {
@@ -80,4 +80,6 @@ int main()
         assert(i == l1.begin());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
index 5cfde77e2..98dcd0ba2 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d(10, 1);
@@ -61,4 +61,6 @@ int main()
     assert(*i++ == 1);
     assert(*i++ == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
index 007026649..22ef0f72b 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
@@ -81,10 +81,12 @@ void test() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int> >();
 #if TEST_STD_VER >= 11
     test<std::list<int, min_allocator<int>>>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
index eefee9123..4ded48991 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<MoveOnly> l1;
@@ -40,4 +40,6 @@ int main()
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
index 2fc8ab7c4..f577fc0bc 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
@@ -44,10 +44,12 @@ void test() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int> >();
 #if TEST_STD_VER >= 11
     test<std::list<int, min_allocator<int>>>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
index 614f57d12..10a3d9704 100644
--- a/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
@@ -46,10 +46,12 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int> >();
 #if TEST_STD_VER >= 11
     test<std::list<int, min_allocator<int>>>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
index 7247e828d..c4c88d421 100644
--- a/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -40,4 +40,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
index 9a0104d03..3decb94c4 100644
--- a/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -39,4 +39,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
index dba7c0f68..e4aa40441 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> c;
@@ -33,4 +33,6 @@ int main()
     assert((c == std::list<int, min_allocator<int>>(a, a+5)));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
index f2b7664a1..a6bbc256e 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
@@ -57,7 +57,7 @@ CMyClass::~CMyClass() {
     assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance;
     std::list<CMyClass> vec;
@@ -70,4 +70,6 @@ int main()
     }
     catch (...) {
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
index 0a4c4014b..5894c2cc8 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<MoveOnly> l1;
@@ -40,4 +40,6 @@ int main()
     assert(l1.front() == MoveOnly(1));
     assert(l1.back() == MoveOnly(2));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
index 980b2515e..27e39e90a 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> c;
@@ -33,4 +33,6 @@ int main()
     assert((c == std::list<int, min_allocator<int>>(a, a+5)));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
index 7b6803961..49f86222a 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
@@ -57,7 +57,7 @@ CMyClass::~CMyClass() {
     assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance;
     std::list<CMyClass> vec;
@@ -70,4 +70,6 @@ int main()
     }
     catch (...) {
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
index 5f74b1597..002011285 100644
--- a/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
+++ b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<MoveOnly> l1;
@@ -40,4 +40,6 @@ int main()
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/merge.pass.cpp b/test/std/containers/sequences/list/list.ops/merge.pass.cpp
index eb60a4165..c2a552cf6 100644
--- a/test/std/containers/sequences/list/list.ops/merge.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/merge.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 3, 7, 9, 10};
@@ -48,4 +48,6 @@ int main()
     assert(c2.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
index d2d048b38..911c3d09a 100644
--- a/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {10, 9, 7, 3, 1};
@@ -48,4 +48,6 @@ int main()
     assert(c2.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/remove.pass.cpp b/test/std/containers/sequences/list/list.ops/remove.pass.cpp
index db6fd89a8..dab23f041 100644
--- a/test/std/containers/sequences/list/list.ops/remove.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/remove.pass.cpp
@@ -32,7 +32,7 @@ struct S {
   int *i_;
 };
 
-int main() {
+int main(int, char**) {
   {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
@@ -79,4 +79,6 @@ int main() {
     assert((c == std::list<int, min_allocator<int>>(a2, a2 + 3)));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
index 29dfafaaa..f903278b3 100644
--- a/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
@@ -29,7 +29,7 @@ bool g(int i)
 
 typedef unary_counting_predicate<bool(*)(int), int> Predicate;
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3, 4};
@@ -60,4 +60,6 @@ int main()
     assert(cp.count() == 4);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/reverse.pass.cpp b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
index a8e5f50a2..0cf1242df 100644
--- a/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
@@ -33,4 +33,6 @@ int main()
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/sort.pass.cpp b/test/std/containers/sequences/list/list.ops/sort.pass.cpp
index 9cc92ef0d..cd229c2d2 100644
--- a/test/std/containers/sequences/list/list.ops/sort.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/sort.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
@@ -33,4 +33,6 @@ int main()
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
index f7dc6b0b3..a87e32acc 100644
--- a/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
@@ -35,7 +35,7 @@ struct throwingLess {
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
@@ -75,4 +75,6 @@ int main()
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
index e1d9f4c52..6a921e25e 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
@@ -780,4 +780,6 @@ int main()
         assert(*i == 6);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
index b87e6b825..9388b559f 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
@@ -334,4 +334,6 @@ int main()
         assert(*i == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
index e4c5752df..d22321b24 100644
--- a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
@@ -214,4 +214,6 @@ int main()
         assert(*i == 4);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/unique.pass.cpp b/test/std/containers/sequences/list/list.ops/unique.pass.cpp
index e5e459491..651ffbc7b 100644
--- a/test/std/containers/sequences/list/list.ops/unique.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/unique.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
@@ -33,4 +33,6 @@ int main()
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
index a3f149d05..dd0bcd77b 100644
--- a/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
+++ b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
@@ -20,7 +20,7 @@ bool g(int x, int y)
     return x == y;
 }
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
@@ -38,4 +38,6 @@ int main()
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.special/swap.pass.cpp b/test/std/containers/sequences/list/list.special/swap.pass.cpp
index de98cfe9f..be7df207b 100644
--- a/test/std/containers/sequences/list/list.special/swap.pass.cpp
+++ b/test/std/containers/sequences/list/list.special/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int a1[] = {1, 3, 7, 9, 10};
@@ -136,4 +136,6 @@ int main()
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
index c6e4f61ef..86634dd83 100644
--- a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
@@ -52,7 +52,7 @@ struct some_alloc2
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::list<MoveOnly> C;
@@ -85,4 +85,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/list/types.pass.cpp b/test/std/containers/sequences/list/types.pass.cpp
index bf872fffd..914f9abab 100644
--- a/test/std/containers/sequences/list/types.pass.cpp
+++ b/test/std/containers/sequences/list/types.pass.cpp
@@ -28,7 +28,7 @@
 
 struct A { std::list<A> v; }; // incomplete type support
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::list<int> C;
@@ -65,4 +65,6 @@ int main()
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/nothing_to_do.pass.cpp b/test/std/containers/sequences/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/containers/sequences/nothing_to_do.pass.cpp
+++ b/test/std/containers/sequences/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp b/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
index cffc3bfff..5aa86839f 100644
--- a/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
@@ -40,4 +40,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<bool>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
index 36d32c73c..bbd980bd3 100644
--- a/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d;
@@ -37,4 +37,6 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/assign_move.pass.cpp b/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
index 59fb08fbf..b70e9cde6 100644
--- a/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
@@ -75,4 +75,6 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/capacity.pass.cpp b/test/std/containers/sequences/vector.bool/capacity.pass.cpp
index 14ebc6c1e..e24ebe00c 100644
--- a/test/std/containers/sequences/vector.bool/capacity.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/capacity.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v;
@@ -40,4 +40,6 @@ int main()
         assert(v.capacity() >= 101);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
index e481ece9f..3fd2bf8d1 100644
--- a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
@@ -59,7 +59,7 @@ test1(const typename C::allocator_type& a)
     assert(c.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     test0<std::vector<bool> >();
@@ -75,4 +75,6 @@ int main()
     test1<std::vector<bool, explicit_allocator<bool> > >(explicit_allocator<bool>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
index 44931a75c..e20f30098 100644
--- a/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
@@ -30,7 +30,7 @@ test(Iterator first, Iterator last)
         assert(*i == *first);
 }
 
-int main()
+int main(int, char**)
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);
@@ -46,4 +46,6 @@ int main()
     test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(a, an);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
index 49d2c23e0..2aa2b4264 100644
--- a/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
@@ -31,7 +31,7 @@ test(Iterator first, Iterator last, const typename C::allocator_type& a)
         assert(*i == *first);
 }
 
-int main()
+int main(int, char**)
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);
@@ -53,4 +53,6 @@ int main()
     test<std::vector<bool, min_allocator<bool>> >(a, an, alloc);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_size.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
index 8300924b6..2763df7e1 100644
--- a/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size.pass.cpp
@@ -56,11 +56,13 @@ test(typename C::size_type n)
     test2<C> ( n );
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<bool> >(50);
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50);
     test2<std::vector<bool, test_allocator<bool>> >( 100, test_allocator<bool>(23));
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
index ecde42678..068989330 100644
--- a/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
@@ -28,10 +28,12 @@ test(typename C::size_type n, const typename C::value_type& x)
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<bool> >(50, true);
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50, true);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
index c94392465..e19f3c4a9 100644
--- a/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
@@ -30,10 +30,12 @@ test(typename C::size_type n, const typename C::value_type& x,
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<bool> >(50, true, std::allocator<bool>());
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50, true, min_allocator<bool>());
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/copy.pass.cpp b/test/std/containers/sequences/vector.bool/copy.pass.cpp
index 66a15a4c8..618a37faf 100644
--- a/test/std/containers/sequences/vector.bool/copy.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/copy.pass.cpp
@@ -29,7 +29,7 @@ test(const C& x)
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
@@ -61,4 +61,6 @@ int main()
         assert(v2.get_allocator() == v.get_allocator());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
index 9a63e5a55..7970b2c7e 100644
--- a/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
@@ -28,7 +28,7 @@ test(const C& x, const typename C::allocator_type& a)
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
@@ -60,4 +60,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<bool>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
index bffeaf64c..800bd1b4b 100644
--- a/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
@@ -30,7 +30,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -50,4 +50,6 @@ int main()
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
index 9d7858b4f..949add271 100644
--- a/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
@@ -26,7 +26,7 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<bool> C;
@@ -46,4 +46,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/emplace.pass.cpp b/test/std/containers/sequences/vector.bool/emplace.pass.cpp
index 26b903907..129cbff15 100644
--- a/test/std/containers/sequences/vector.bool/emplace.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/emplace.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<bool> C;
@@ -63,4 +63,6 @@ int main()
         assert(c[1] == true);
         assert(c.back() == true);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp b/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
index 0ad721002..974b7c24a 100644
--- a/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<bool> C;
@@ -87,4 +87,6 @@ int main()
         assert(c[1] == true);
         assert(c.back() == true);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/empty.fail.cpp b/test/std/containers/sequences/vector.bool/empty.fail.cpp
index 0381d7eb2..0a84eb79d 100644
--- a/test/std/containers/sequences/vector.bool/empty.fail.cpp
+++ b/test/std/containers/sequences/vector.bool/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::vector<bool> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/empty.pass.cpp b/test/std/containers/sequences/vector.bool/empty.pass.cpp
index e3226a128..e0c0243e1 100644
--- a/test/std/containers/sequences/vector.bool/empty.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<bool> C;
@@ -42,4 +42,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp b/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
index ba8bdf531..f6631cf2d 100644
--- a/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
@@ -18,10 +18,12 @@
 #include "poisoned_hash_helper.hpp"
 #include "min_allocator.h"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::vector<bool> >();
     test_hash_enabled_for_type<std::vector<bool, min_allocator<bool>>>();
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp b/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
index b0a65c9ae..c3d6bfd5d 100644
--- a/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     bool a1[] = {1, 0, 1};
     {
@@ -61,4 +61,6 @@ int main()
     assert(distance(l1.begin(), l1.end()) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
index b57455230..89763017e 100644
--- a/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     bool a1[] = {1, 0, 1};
     {
@@ -81,4 +81,6 @@ int main()
         assert(i == l1.begin());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/find.pass.cpp b/test/std/containers/sequences/vector.bool/find.pass.cpp
index 265b519de..883b5b4db 100644
--- a/test/std/containers/sequences/vector.bool/find.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/find.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         for (unsigned i = 1; i < 256; ++i)
@@ -38,4 +38,6 @@ int main()
             assert(b.end() == j);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
index 9f9967589..d510b86fe 100644
--- a/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d = {true, false, false, true};
@@ -35,4 +35,6 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
index 29164b598..27d8420a6 100644
--- a/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool, test_allocator<bool>> d({true, false, false, true}, test_allocator<bool>(3));
@@ -38,4 +38,6 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
index 3760a9611..519752da1 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d(10, true);
@@ -59,4 +59,6 @@ int main()
     assert(d[12] == true);
     assert(d[13] == true);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
index 7180bb8c2..b9a921891 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -125,4 +125,6 @@ int main()
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
index 9e13af2ac..5774ab5f6 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -78,4 +78,6 @@ int main()
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp b/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
index 1c0e8ed03..2502865c7 100644
--- a/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -74,4 +74,6 @@ int main()
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/iterators.pass.cpp b/test/std/containers/sequences/vector.bool/iterators.pass.cpp
index 0780d1dd0..7714e53b2 100644
--- a/test/std/containers/sequences/vector.bool/iterators.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/iterators.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef bool T;
@@ -120,4 +120,6 @@ int main()
         assert (ii1 - cii == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/move.pass.cpp b/test/std/containers/sequences/vector.bool/move.pass.cpp
index e5752e084..4de0604c6 100644
--- a/test/std/containers/sequences/vector.bool/move.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
@@ -89,4 +89,6 @@ int main()
         assert(a.get_data() == 42);
       }
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp b/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
index bcf57b6c2..f2ff5303b 100644
--- a/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
@@ -71,4 +71,6 @@ int main()
         assert(l.empty());
         assert(l2.get_allocator() == min_allocator<bool>());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
index 60517e206..6c7fcfca7 100644
--- a/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
@@ -56,7 +56,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -97,4 +97,6 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
index 8326e4c42..a59e1a8eb 100644
--- a/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
@@ -28,7 +28,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -56,4 +56,6 @@ int main()
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
index 5263fa3bd..22384fe8d 100644
--- a/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d;
@@ -37,4 +37,6 @@ int main()
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/push_back.pass.cpp b/test/std/containers/sequences/vector.bool/push_back.pass.cpp
index 2e7d82d96..438869be1 100644
--- a/test/std/containers/sequences/vector.bool/push_back.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/push_back.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         bool a[] = {0, 1, 1, 0, 1, 0, 0};
@@ -45,4 +45,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
index 22e109142..c41bac188 100644
--- a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
     bool a[] = {false, true, false, true};
@@ -35,4 +35,6 @@ int main()
     v.swap(r1, r2);
     assert( r1);
     assert(!r2);
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/reserve.pass.cpp b/test/std/containers/sequences/vector.bool/reserve.pass.cpp
index b7430453f..039c1bc18 100644
--- a/test/std/containers/sequences/vector.bool/reserve.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/reserve.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v;
@@ -50,4 +50,6 @@ int main()
         assert(v.capacity() >= 150);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/resize_size.pass.cpp b/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
index 3d926910c..53e83ac7e 100644
--- a/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/resize_size.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -46,4 +46,6 @@ int main()
         assert(v.capacity() >= 400);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp b/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
index 061f8a505..ef0cb6160 100644
--- a/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -48,4 +48,6 @@ int main()
             assert(v[i] == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp b/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
index 988ce6e03..59714d5fb 100644
--- a/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -34,4 +34,6 @@ int main()
         assert(v.size() >= 101);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/size.pass.cpp b/test/std/containers/sequences/vector.bool/size.pass.cpp
index d8abef989..db737c930 100644
--- a/test/std/containers/sequences/vector.bool/size.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<bool> C;
@@ -58,4 +58,6 @@ int main()
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/swap.pass.cpp b/test/std/containers/sequences/vector.bool/swap.pass.cpp
index 9aa579d4a..9ff11113d 100644
--- a/test/std/containers/sequences/vector.bool/swap.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v1(100);
@@ -94,4 +94,6 @@ int main()
         assert(v[1] == true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
index dbf0f821f..e346c2998 100644
--- a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
@@ -52,7 +52,7 @@ struct some_alloc2
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -89,4 +89,6 @@ int main()
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/types.pass.cpp b/test/std/containers/sequences/vector.bool/types.pass.cpp
index 4736f8ac9..d15973a38 100644
--- a/test/std/containers/sequences/vector.bool/types.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/types.pass.cpp
@@ -67,7 +67,7 @@ test()
         std::reverse_iterator<typename C::const_iterator> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<test_allocator<bool> >();
     test<std::allocator<bool> >();
@@ -76,4 +76,6 @@ int main()
 #if TEST_STD_VER >= 11
     test<min_allocator<bool> >();
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp b/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
index c0d27e4d2..5f9ae3dec 100644
--- a/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<bool> T;
@@ -50,4 +50,6 @@ int main()
     assert(h(vb) != 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp b/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
index 001af6298..0c57f16be 100644
--- a/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
+++ b/test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <vector>
 
-int main()
+int main(int, char**)
 {
     std::vector<int, std::allocator<long> > v;
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/contiguous.pass.cpp b/test/std/containers/sequences/vector/contiguous.pass.cpp
index 2ac79be6a..99d9d6eca 100644
--- a/test/std/containers/sequences/vector/contiguous.pass.cpp
+++ b/test/std/containers/sequences/vector/contiguous.pass.cpp
@@ -23,7 +23,7 @@ void test_contiguous ( const C &c )
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -48,4 +48,6 @@ int main()
     test_contiguous(C(9, 11.0, A{}));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/iterators.pass.cpp b/test/std/containers/sequences/vector/iterators.pass.cpp
index f8b8ca317..296c551f7 100644
--- a/test/std/containers/sequences/vector/iterators.pass.cpp
+++ b/test/std/containers/sequences/vector/iterators.pass.cpp
@@ -28,7 +28,7 @@ struct A
     int second;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -166,4 +166,6 @@ int main()
         assert (ii1 - cii == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/types.pass.cpp b/test/std/containers/sequences/vector/types.pass.cpp
index 101355bee..0a04c2552 100644
--- a/test/std/containers/sequences/vector/types.pass.cpp
+++ b/test/std/containers/sequences/vector/types.pass.cpp
@@ -78,7 +78,7 @@ test()
         std::reverse_iterator<typename C::const_iterator> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<int, test_allocator<int> >();
     test<int*, std::allocator<int*> >();
@@ -104,4 +104,6 @@ int main()
 //         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
index 58dccba22..a8ee9f229 100644
--- a/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -44,4 +44,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp b/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
index 8085bd484..0f7dc6c64 100644
--- a/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::vector<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
index 594b9e4f4..cce2602bd 100644
--- a/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> C;
@@ -42,4 +42,6 @@ int main()
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
index 3e18d4a4d..c9cc6d582 100644
--- a/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::vector<int, A> C;
@@ -44,4 +44,6 @@ int main() {
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
index 48f57c99c..4cf3b2d33 100644
--- a/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -66,4 +66,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
index d4b282518..41188acb7 100644
--- a/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -80,4 +80,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
index 35b63756a..4d9f7931d 100644
--- a/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -73,4 +73,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
index 1b8d2815c..36125bb93 100644
--- a/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -58,4 +58,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
index 8944eca42..373a7069f 100644
--- a/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> C;
@@ -58,4 +58,6 @@ int main()
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
index f66eafe25..e2fa0d8b9 100644
--- a/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v1(100);
@@ -46,4 +46,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
index 2c087fb49..f6d8dd50b 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
@@ -40,4 +40,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
index c64c8bf3b..4673df955 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
@@ -30,7 +30,7 @@ void test ( Vec &v )
     assert(v[3] == 6);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> V;
@@ -48,4 +48,6 @@ int main()
     test(d1);
     test(d2);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
index 888ffb105..df8450210 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
@@ -69,7 +69,9 @@ void test_emplaceable_concept() {
 
 
 
-int main()
+int main(int, char**)
 {
     test_emplaceable_concept();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
index 1a915060c..4b70c7843 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -95,4 +95,6 @@ int main()
         assert(l2.get_allocator() == lo.get_allocator());
         assert(is_contiguous_container_asan_correct(l2));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
index 4f0530722..b85238db9 100644
--- a/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
@@ -29,7 +29,7 @@ void test ( Vec &v )
     assert(std::all_of(v.begin(), v.end(), is6));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> V;
@@ -50,4 +50,6 @@ int main()
     test(d2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
index c31b3c2fa..346c357d3 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
@@ -60,7 +60,7 @@ test1(const typename C::allocator_type& a)
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main()
+int main(int, char**)
 {
     {
     test0<std::vector<int> >();
@@ -98,4 +98,6 @@ int main()
         assert(v.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index 1623c8296..8f8ffa82c 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -176,9 +176,11 @@ void test_ctor_with_different_value_type() {
 }
 
 
-int main() {
+int main(int, char**) {
   basic_test_cases();
   emplaceable_concept_tests(); // See PR34898
   test_ctor_under_alloc();
   test_ctor_with_different_value_type();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
index 6cd319bc8..3a97b43b7 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -162,8 +162,10 @@ void test_ctor_under_alloc() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_tests();
   emplaceable_concept_tests(); // See PR34898
   test_ctor_under_alloc();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
index fe20a7036..f111220d3 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
@@ -60,7 +60,7 @@ test(typename C::size_type n)
     test2<C> ( n );
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >(50);
     test<std::vector<DefaultOnly> >(500);
@@ -71,4 +71,6 @@ int main()
     test2<std::vector<DefaultOnly, test_allocator<DefaultOnly>> >( 100, test_allocator<DefaultOnly>(23));
     assert(DefaultOnly::count == 0);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
index c8cd2f2a3..0839883a9 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
@@ -30,7 +30,7 @@ test(typename C::size_type n, const typename C::value_type& x)
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >(50, 3);
     // Add 1 for implementations that dynamically allocate a container proxy.
@@ -38,4 +38,6 @@ int main()
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50, 3);
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
index c0bba42da..1de088534 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
@@ -31,10 +31,12 @@ test(typename C::size_type n, const typename C::value_type& x,
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >(50, 3, std::allocator<int>());
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50, 3, min_allocator<int>());
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp b/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
index 1542827e3..844da3841 100644
--- a/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
@@ -30,7 +30,7 @@ test(const C& x)
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main()
+int main(int, char**)
 {
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
@@ -74,4 +74,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
index d54fc59f5..79b484f78 100644
--- a/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
@@ -30,7 +30,7 @@ test(const C& x, const typename C::allocator_type& a)
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main()
+int main(int, char**)
 {
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
@@ -62,4 +62,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp b/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
index 0ce0bafbf..beb10498c 100644
--- a/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
@@ -23,7 +23,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -36,4 +36,6 @@ int main()
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp b/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
index 0ada98c0c..e6b59b40c 100644
--- a/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -112,4 +112,6 @@ int main()
     static_assert(std::is_same_v<decltype(vec)::allocator_type, std::allocator<bool>>, "");
     assert(vec.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp b/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
index e7298ba85..1558ea4b6 100644
--- a/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
@@ -17,6 +17,8 @@ struct X
     std::vector<X> q;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
index 24f78b282..91434964b 100644
--- a/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -47,4 +47,6 @@ int main()
         typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
index e02a7b029..f4c05b6e2 100644
--- a/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@ struct some_alloc
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -47,4 +47,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
index a839e0366..168e3b58b 100644
--- a/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> d = {3, 4, 5, 6};
@@ -37,4 +37,6 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
index f8ea034f7..633b5c5e2 100644
--- a/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
@@ -41,4 +41,6 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/move.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
index e5d625b5e..938857458 100644
--- a/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -129,4 +129,6 @@ int main()
         assert(a.get_data() == 42);
       }
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
index dcea27a0d..2f15a14e8 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -93,4 +93,6 @@ int main()
         assert(l2.get_allocator() == min_allocator<MoveOnly>());
         assert(is_contiguous_container_asan_correct(l2));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
index 8eeb19eb4..c5c5e29cd 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
@@ -57,7 +57,7 @@ struct some_alloc3
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -91,4 +91,6 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
index a9a554ad2..122841428 100644
--- a/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
@@ -28,7 +28,7 @@ struct some_alloc
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -51,4 +51,6 @@ int main()
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
index 941f1e012..61c20b7c7 100644
--- a/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> d;
@@ -40,4 +40,6 @@ int main()
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.data/data.pass.cpp b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
index cd176c701..3477c5eb1 100644
--- a/test/std/containers/sequences/vector/vector.data/data.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
@@ -25,7 +25,7 @@ struct Nasty {
     int i_;
     };
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -59,4 +59,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
index 33d973954..ec5016d2f 100644
--- a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
@@ -25,7 +25,7 @@ struct Nasty {
     int i_;
     };
 
-int main()
+int main(int, char**)
 {
     {
         const std::vector<int> v;
@@ -59,4 +59,6 @@ int main()
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp b/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
index 3a96b55ca..00676b52d 100644
--- a/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::vector<long>>();
     test<std::vector<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp b/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
index f18c40483..10d66a29b 100644
--- a/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@ void test()
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@ int main()
 
     test<std::vector<long>>();
     test<std::vector<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
index a1ce8f000..334c67adc 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -39,4 +39,6 @@ int main()
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
index 7acc90b5a..1279fba4c 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
@@ -52,7 +52,7 @@ public:
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<A> c;
@@ -132,4 +132,6 @@ int main()
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
index 6ddc88560..435be207b 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
@@ -53,7 +53,7 @@ public:
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<A> c;
@@ -144,4 +144,6 @@ int main()
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
index 45835c338..ec5f77856 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -56,4 +56,6 @@ int main()
         assert(v[0] == 3);
         assert(is_contiguous_container_asan_correct(v));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
index def3b350d..aac35f9f8 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
@@ -32,7 +32,7 @@ struct Throws {
 bool Throws::sThrows = false;
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -99,4 +99,6 @@ int main()
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
index aab348f08..7682000d7 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
@@ -32,7 +32,7 @@ struct Throws {
 bool Throws::sThrows = false;
 #endif
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     {
@@ -152,4 +152,6 @@ int main()
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
index 46b6c010a..30d0cd686 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> d(10, 1);
@@ -62,4 +62,6 @@ int main()
     assert(d[12] == 1);
     assert(d[13] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
index fadd09e3e..74cb612aa 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<int> V;
@@ -171,4 +171,6 @@ int main()
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
index e2190fd88..780bd9c48 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly> v(100);
@@ -62,4 +62,6 @@ int main()
         for (++j; j < 101; ++j)
             assert(v[j] == MoveOnly());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
index ddaa4fb6a..5b182f44d 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -111,4 +111,6 @@ int main()
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
index 23f0030ab..2edadd0fe 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -93,4 +93,6 @@ int main()
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
index c0784f703..db2337c27 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> c;
@@ -37,4 +37,6 @@ int main()
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
index e9bcf2411..d22136ddb 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> c;
@@ -108,4 +108,6 @@ int main()
             assert(c[j] == j);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
index 48152cb81..9e2561129 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
@@ -64,7 +64,7 @@ CMyClass::~CMyClass() {
 
 bool operator==(const CMyClass &lhs, const CMyClass &rhs) { return lhs.equal(rhs); }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance(42);
     std::vector<CMyClass> vec;
@@ -85,4 +85,6 @@ int main()
         assert(is_contiguous_container_asan_correct(vec));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
index 070cabe5c..d876eb617 100644
--- a/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly> c;
@@ -109,4 +109,6 @@ int main()
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.special/swap.pass.cpp b/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
index d107be98f..2ded4fe75 100644
--- a/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/swap.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         int a1[] = {1, 3, 7, 9, 10};
@@ -178,4 +178,6 @@ int main()
         assert(is_contiguous_container_asan_correct(c2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
index 06d89282f..40205b67c 100644
--- a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
@@ -53,7 +53,7 @@ struct some_alloc2
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -85,4 +85,6 @@ int main()
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/iterator_difference_type.pass.cpp b/test/std/containers/unord/iterator_difference_type.pass.cpp
index 3f0b61e5f..fc5ccbee3 100644
--- a/test/std/containers/unord/iterator_difference_type.pass.cpp
+++ b/test/std/containers/unord/iterator_difference_type.pass.cpp
@@ -73,7 +73,7 @@ void testUnorderedSet() {
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef std::unordered_map<int, int> Map;
     typedef std::pair<const int, int> ValueTp;
@@ -150,4 +150,6 @@ int main() {
     testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
index 9dc9869ea..705922042 100644
--- a/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_map>
 
-int main()
+int main(int, char**)
 {
     std::unordered_map<int, int, std::hash<int>, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/bucket.pass.cpp b/test/std/containers/unord/unord.map/bucket.pass.cpp
index ae65ac887..522b70976 100644
--- a/test/std/containers/unord/unord.map/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -74,4 +74,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/bucket_count.pass.cpp b/test/std/containers/unord/unord.map/bucket_count.pass.cpp
index b2529a831..ee1a12523 100644
--- a/test/std/containers/unord/unord.map/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket_count.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -71,4 +71,6 @@ int main()
         assert(c.bucket_count() >= 8);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/bucket_size.pass.cpp b/test/std/containers/unord/unord.map/bucket_size.pass.cpp
index 2edb6cc20..439d2b533 100644
--- a/test/std/containers/unord/unord.map/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/bucket_size.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -78,4 +78,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/compare.pass.cpp b/test/std/containers/unord/unord.map/compare.pass.cpp
index 6c5891e1a..7d6cbf9a8 100644
--- a/test/std/containers/unord/unord.map/compare.pass.cpp
+++ b/test/std/containers/unord/unord.map/compare.pass.cpp
@@ -32,7 +32,7 @@ namespace std
     };
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::unordered_map<Key, int> MapT;
     typedef MapT::iterator Iter;
@@ -42,4 +42,6 @@ int main()
     std::pair<Iter, bool> result = map.insert(std::make_pair(Key(0), 42));
     assert(result.second);
     assert(result.first->second == 42);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/count.pass.cpp b/test/std/containers/unord/unord.map/count.pass.cpp
index bd754843c..1a1bea90b 100644
--- a/test/std/containers/unord/unord.map/count.pass.cpp
+++ b/test/std/containers/unord/unord.map/count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -61,4 +61,6 @@ int main()
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/empty.fail.cpp b/test/std/containers/unord/unord.map/empty.fail.cpp
index c4fa89e66..283d6fa3e 100644
--- a/test/std/containers/unord/unord.map/empty.fail.cpp
+++ b/test/std/containers/unord/unord.map/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_map<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/empty.pass.cpp b/test/std/containers/unord/unord.map/empty.pass.cpp
index 1dcba5cf7..da6d48df2 100644
--- a/test/std/containers/unord/unord.map/empty.pass.cpp
+++ b/test/std/containers/unord/unord.map/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, double> M;
@@ -42,4 +42,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/eq.pass.cpp b/test/std/containers/unord/unord.map/eq.pass.cpp
index 99bd1fa67..d284e822a 100644
--- a/test/std/containers/unord/unord.map/eq.pass.cpp
+++ b/test/std/containers/unord/unord.map/eq.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -159,4 +159,6 @@ int main()
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/equal_range_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
index a3b2b5c8a..b9dd9a64e 100644
--- a/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/equal_range_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -71,4 +71,6 @@ int main()
         assert(std::distance(r.first, r.second) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
index 505d355d7..029222d5c 100644
--- a/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -71,4 +71,6 @@ int main()
         assert(std::distance(r.first, r.second) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/erase_if.pass.cpp b/test/std/containers/unord/unord.map/erase_if.pass.cpp
index 5238d9ee0..5498f4543 100644
--- a/test/std/containers/unord/unord.map/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.map/erase_if.pass.cpp
@@ -67,7 +67,7 @@ void test()
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_map<int, int>>();
     test<std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -75,5 +75,7 @@ int main()
 
     test<std::unordered_map<long, short>>();
     test<std::unordered_map<short, double>>();
+
+  return 0;
 }
 
diff --git a/test/std/containers/unord/unord.map/find_const.pass.cpp b/test/std/containers/unord/unord.map/find_const.pass.cpp
index 65c2a1208..1d63b4be2 100644
--- a/test/std/containers/unord/unord.map/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/find_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -67,4 +67,6 @@ int main()
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/find_non_const.pass.cpp b/test/std/containers/unord/unord.map/find_non_const.pass.cpp
index e6efa8e06..58a9cd35a 100644
--- a/test/std/containers/unord/unord.map/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.map/find_non_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -67,4 +67,6 @@ int main()
         assert(i == c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/incomplete_type.pass.cpp b/test/std/containers/unord/unord.map/incomplete_type.pass.cpp
index f6faaac50..ddcd6e14c 100644
--- a/test/std/containers/unord/unord.map/incomplete_type.pass.cpp
+++ b/test/std/containers/unord/unord.map/incomplete_type.pass.cpp
@@ -31,6 +31,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/iterators.pass.cpp b/test/std/containers/unord/unord.map/iterators.pass.cpp
index 609e7d7c4..0b4e02e33 100644
--- a/test/std/containers/unord/unord.map/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.map/iterators.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -126,4 +126,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/load_factor.pass.cpp b/test/std/containers/unord/unord.map/load_factor.pass.cpp
index 418cdf7fd..7a5fde8a4 100644
--- a/test/std/containers/unord/unord.map/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.map/load_factor.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -73,4 +73,6 @@ int main()
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/local_iterators.pass.cpp b/test/std/containers/unord/unord.map/local_iterators.pass.cpp
index f51df4878..e24e1811a 100644
--- a/test/std/containers/unord/unord.map/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.map/local_iterators.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -417,4 +417,6 @@ int main()
         assert(i->second == "four");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
index d9c03128a..eb8f3e9d2 100644
--- a/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -36,4 +36,6 @@ int main()
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/max_load_factor.pass.cpp b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
index e57eb71d3..8620dd1bd 100644
--- a/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_load_factor.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -65,4 +65,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/max_size.pass.cpp b/test/std/containers/unord/unord.map/max_size.pass.cpp
index 3dc62d0b8..7c2ec58de 100644
--- a/test/std/containers/unord/unord.map/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -49,4 +49,6 @@ int main()
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/rehash.pass.cpp b/test/std/containers/unord/unord.map/rehash.pass.cpp
index ff7b1b75f..c8f079fb6 100644
--- a/test/std/containers/unord/unord.map/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.map/rehash.pass.cpp
@@ -37,7 +37,7 @@ void test(const C& c)
     assert(c.at(4) == "four");
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -100,4 +100,6 @@ int main()
         test(c);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/reserve.pass.cpp b/test/std/containers/unord/unord.map/reserve.pass.cpp
index 983c87237..622a9691e 100644
--- a/test/std/containers/unord/unord.map/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.map/reserve.pass.cpp
@@ -46,7 +46,7 @@ void reserve_invariant(size_t n) // LWG #2156
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -104,4 +104,6 @@ int main()
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/size.pass.cpp b/test/std/containers/unord/unord.map/size.pass.cpp
index 22a922d1f..d4e7cb97f 100644
--- a/test/std/containers/unord/unord.map/size.pass.cpp
+++ b/test/std/containers/unord/unord.map/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, double> M;
@@ -58,4 +58,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/swap_member.pass.cpp b/test/std/containers/unord/unord.map/swap_member.pass.cpp
index 2763940f8..ff9b32e3e 100644
--- a/test/std/containers/unord/unord.map/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.map/swap_member.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -567,4 +567,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/types.pass.cpp b/test/std/containers/unord/unord.map/types.pass.cpp
index 1c8c86b5d..e194f69f8 100644
--- a/test/std/containers/unord/unord.map/types.pass.cpp
+++ b/test/std/containers/unord/unord.map/types.pass.cpp
@@ -32,7 +32,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<char, short> C;
@@ -68,4 +68,6 @@ int main()
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
index 0c1ee685b..8f1d7561b 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -126,4 +126,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
index 2820e66a8..a5a67bcc2 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -185,4 +185,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
index 8f651b929..e9e628988 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
@@ -27,7 +27,7 @@
 #include "../../../test_hash.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::allocator<std::pair<const int, std::string> > A;
@@ -93,4 +93,6 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
index ab0df753a..87b80cef1 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -214,4 +214,6 @@ int main()
         assert(c.max_load_factor() == 1);
         assert(c0.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
index 1a3cbc386..2591c99f4 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_map<int, int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
index c8e1d73d0..ee4bc43a5 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -148,4 +148,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
index 939e30c82..8e7a3a079 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -148,4 +148,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
index fe95ce8f8..bda7d24a6 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -108,4 +108,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
index cf00bb116..a4af74a89 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
@@ -45,7 +45,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -72,4 +72,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
index 247e57600..4f4331fa0 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
@@ -38,7 +38,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
@@ -65,4 +65,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
index 3da628240..026e319fc 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@ private:
 };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_map<int, int, Hash<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
index 6b00cb7c5..00b4a2f0b 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -159,4 +159,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif // TEST_STD_VER > 11
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
index 702b9231e..f1dbad9fe 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -97,4 +97,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
index 57f6dca54..c0c3d5c5b 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -99,4 +99,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
index d8d073a4d..5c87af0a1 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -102,4 +102,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
index 0bce91b3a..5ab0366da 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -140,4 +140,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
index fdcd596e9..d4eed3c03 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -176,4 +176,6 @@ int main()
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
index 82e83ba48..be72227da 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, std::string> P;
@@ -195,4 +195,6 @@ int main()
 
         assert(c0.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
index 71e913f27..78ac7d787 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
@@ -44,7 +44,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
@@ -71,4 +71,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
index 09fefc4ba..62175145d 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
@@ -41,7 +41,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -68,4 +68,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
index 002a39a86..a6d871508 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -169,4 +169,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
index e9ce1a29f..66e0ac3a7 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -104,4 +104,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
index 5240d2b52..62a590736 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -107,4 +107,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
index a8f69b235..70e391d46 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -109,4 +109,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
index 9c8f221f3..1f29c5414 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -150,4 +150,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
index 50252dd5b..9a715b6a1 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
index d9af5a322..41cfc7104 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
index 2c69847d9..f97ee39fb 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -70,4 +70,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
index b47f309f9..8c306364e 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -72,4 +72,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
index 1e821b8c6..40b9d01a2 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -96,4 +96,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
index 11db9bff7..fe6ef8bc7 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -140,4 +140,6 @@ int main()
 #endif
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
index 4ddb9f986..ff83f1d68 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
@@ -28,7 +28,7 @@
 #include "container_test_types.h"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -159,4 +159,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
index feea53ecd..4719b5583 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
@@ -28,8 +28,10 @@ struct my_hash
     size_t operator()(const tuple<int,int>&) const {return 0;}
 };
 
-int main()
+int main(int, char**)
 {
     unordered_map<tuple<int,int>, size_t, my_hash> m;
     m[make_tuple(2,3)]=7;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
index 6b0f03d9c..64fe72ecd 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -60,4 +60,6 @@ int main()
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
index 2ea264b53..63a269601 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, Emplaceable> C;
@@ -74,4 +74,6 @@ int main()
         assert(r.first->first == 5);
         assert(r.first->second == Emplaceable(6, 7));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
index a130d65c0..01e8d9c6f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
@@ -24,7 +24,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, Emplaceable> C;
@@ -71,4 +71,6 @@ int main()
         assert(r->first == 5);
         assert(r->second == Emplaceable(6, 7));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
index 78e70fbba..1d0b18bf1 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
@@ -30,7 +30,7 @@ struct TemplateConstructor
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -89,4 +89,6 @@ int main()
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
index b923752ef..38ba03d5e 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -31,8 +31,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
index fcc499ebf..887f7859b 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -34,8 +34,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
index fd9931ad2..15c6745ad 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
index 9f64445af..0ae0674ad 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
index 16cf5367f..134d075ec 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
index 2c5909345..17745175b 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
index aa2dea3d9..305d149a5 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
@@ -38,7 +38,7 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -174,4 +174,6 @@ int main()
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
index 5c2c676f2..839d65733 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -95,4 +95,6 @@ int main()
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
index 332eea13f..3ad30510f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::unordered_map<int, int>;
@@ -63,4 +63,6 @@ int main()
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
index 3272a4383..4d6c24e6e 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_map<int, int> m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}};
@@ -72,4 +72,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
index f84e98c2b..71d456e66 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -21,10 +21,12 @@
 #include "container_test_types.h"
 #include "../../../map_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMapInsert<TCT::unordered_map<> >();
   testMapInsertHint<TCT::unordered_map<> >();
   testMapEmplace<TCT::unordered_map<> >();
   testMapEmplaceHint<TCT::unordered_map<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
index 3b4b7db1d..eb505218f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
@@ -65,7 +65,7 @@ void do_insert_cv_test()
     assert(r.first->second == 3);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<double, int> M;
@@ -78,4 +78,6 @@ int main()
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
index 60c5d359c..b1b77eb9c 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -56,7 +56,7 @@ void do_insert_hint_const_lvalue_test()
     assert(r->second == 4);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_map<double, int> >();
 #if TEST_STD_VER >= 11
@@ -80,4 +80,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
index 4670fbfbe..b7374d1a6 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
@@ -28,7 +28,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<double, int> C;
@@ -173,4 +173,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
index 20b5fb649..27e874734 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -66,4 +66,6 @@ int main()
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
index 5840950d7..24d0a23a5 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
@@ -74,10 +74,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_map<int, int> m;
     test(m);
     std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
index 3a9786880..21ccb88ca 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
@@ -54,10 +54,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_map<int, int> m;
     test(m);
     std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
index 5c02fc129..7fc3ff187 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
@@ -61,7 +61,7 @@ namespace std {
     };
 }
 
-int main()
+int main(int, char**)
 {
 
     { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
@@ -188,4 +188,6 @@ int main()
         assert(r->second.get() == 5);  // value
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
index a70703b5f..1d51bdb4f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -67,4 +67,6 @@ int main()
         assert(c.at(4) == "four");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
index ed0a2a58d..1f8528ab5 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
@@ -24,7 +24,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<double, int> C;
@@ -172,4 +172,6 @@ int main()
         assert(r.first->first == 5.5);
         assert(r.first->second == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
index 17be66154..1437d46d2 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_hasher
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_map<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -153,4 +153,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
index dbdb1b89b..c3ee0050a 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
@@ -60,7 +60,7 @@ namespace std {
     };
 }
 
-int main()
+int main(int, char**)
 {
 
     { // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
@@ -185,4 +185,6 @@ int main()
         assert(r->first.get()  == 3); // key
         assert(r->second.get() == 4); // value
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
index e47e7b660..67a49d4bb 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -40,4 +40,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
index 2522270fd..44ee7be49 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
@@ -119,7 +119,7 @@ struct some_alloc3
 };
 
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> MapType;
     {
@@ -188,4 +188,6 @@ int main()
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
index 9966bcd4f..7852394cd 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -567,4 +567,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
index f1e7a2a96..ba24ca3cc 100644
--- a/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_map>
 
-int main()
+int main(int, char**)
 {
     std::unordered_multimap<int, int, std::hash<int>, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/bucket.pass.cpp b/test/std/containers/unord/unord.multimap/bucket.pass.cpp
index 7b10eb86b..c6c8b217c 100644
--- a/test/std/containers/unord/unord.multimap/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -74,4 +74,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp b/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
index 340c1dcc2..9c0735719 100644
--- a/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -44,4 +44,6 @@ int main()
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp b/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
index b7c7d653f..f49197521 100644
--- a/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -82,4 +82,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/count.pass.cpp b/test/std/containers/unord/unord.multimap/count.pass.cpp
index 15134dd0f..4a6ec5d65 100644
--- a/test/std/containers/unord/unord.multimap/count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@ int main()
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
index 2cffa13a4..463b49938 100644
--- a/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -52,8 +52,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
index 62da82f2d..38395e5f9 100644
--- a/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -48,8 +48,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
index a609b5dd0..04d8b3ff0 100644
--- a/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
index a397cad56..69ef06993 100644
--- a/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/empty.fail.cpp b/test/std/containers/unord/unord.multimap/empty.fail.cpp
index 93ec56e94..4eb7bfc9c 100644
--- a/test/std/containers/unord/unord.multimap/empty.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_multimap<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/empty.pass.cpp b/test/std/containers/unord/unord.multimap/empty.pass.cpp
index 58f4e602f..6189b7f0e 100644
--- a/test/std/containers/unord/unord.multimap/empty.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, double> M;
@@ -42,4 +42,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/eq.pass.cpp b/test/std/containers/unord/unord.multimap/eq.pass.cpp
index 85dfb0092..575191687 100644
--- a/test/std/containers/unord/unord.multimap/eq.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/eq.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -177,4 +177,6 @@ int main()
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
index 88686a1fd..148081be7 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -100,4 +100,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
index 5e833c978..5da87166b 100644
--- a/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -100,4 +100,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/erase_if.pass.cpp b/test/std/containers/unord/unord.multimap/erase_if.pass.cpp
index ef44cd81b..2cec09205 100644
--- a/test/std/containers/unord/unord.multimap/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/erase_if.pass.cpp
@@ -78,7 +78,7 @@ void test()
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_multimap<int, int>>();
     test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -86,4 +86,6 @@ int main()
 
     test<std::unordered_multimap<long, short>>();
     test<std::unordered_multimap<short, double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/find_const.pass.cpp b/test/std/containers/unord/unord.multimap/find_const.pass.cpp
index c48d6ffff..271bf9d0c 100644
--- a/test/std/containers/unord/unord.multimap/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/find_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@ int main()
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp b/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
index b8975ef09..3e642e346 100644
--- a/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@ int main()
         assert(i == c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/incomplete.pass.cpp b/test/std/containers/unord/unord.multimap/incomplete.pass.cpp
index 77f03f51f..6ea493129 100644
--- a/test/std/containers/unord/unord.multimap/incomplete.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/incomplete.pass.cpp
@@ -31,6 +31,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/iterators.fail.cpp b/test/std/containers/unord/unord.multimap/iterators.fail.cpp
index aed2f7138..0c1b50fac 100644
--- a/test/std/containers/unord/unord.multimap/iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/iterators.fail.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@ int main()
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/iterators.pass.cpp b/test/std/containers/unord/unord.multimap/iterators.pass.cpp
index e669be6f3..5fd52beeb 100644
--- a/test/std/containers/unord/unord.multimap/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/iterators.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -132,4 +132,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/load_factor.pass.cpp b/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
index f1624616e..ae8a8403b 100644
--- a/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/load_factor.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -72,4 +72,6 @@ int main()
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp b/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
index 313c9e378..f5af79180 100644
--- a/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -284,4 +284,6 @@ int main()
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
index 61815a9c6..b5dd2d4b0 100644
--- a/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -658,4 +658,6 @@ int main()
         assert(std::distance(i, j) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
index b2442ff87..c55f4de8d 100644
--- a/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -35,4 +35,6 @@ int main()
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp b/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
index a75052ebd..ed46b681b 100644
--- a/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -63,4 +63,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/max_size.pass.cpp b/test/std/containers/unord/unord.multimap/max_size.pass.cpp
index 5ed732902..d03cf67ae 100644
--- a/test/std/containers/unord/unord.multimap/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -51,4 +51,6 @@ int main()
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index aa8996a1a..99538e32d 100644
--- a/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -81,7 +81,7 @@ void test(const C& c)
     assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -144,4 +144,6 @@ int main()
         test(c);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/reserve.pass.cpp b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
index 1771faa60..811ac97fb 100644
--- a/test/std/containers/unord/unord.multimap/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/reserve.pass.cpp
@@ -61,7 +61,7 @@ void reserve_invariant(size_t n) // LWG #2156
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -119,4 +119,6 @@ int main()
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/scary.pass.cpp b/test/std/containers/unord/unord.multimap/scary.pass.cpp
index 321c38ceb..4c4b1cd11 100644
--- a/test/std/containers/unord/unord.multimap/scary.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <unordered_map>
 
-int main()
+int main(int, char**)
 {
     typedef std::unordered_map<int, int> M1;
     typedef std::unordered_multimap<int, int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/size.pass.cpp b/test/std/containers/unord/unord.multimap/size.pass.cpp
index c24d93b5b..493b8d757 100644
--- a/test/std/containers/unord/unord.multimap/size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, double> M;
@@ -58,4 +58,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
index f57d82109..75806df97 100644
--- a/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -653,4 +653,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/types.pass.cpp b/test/std/containers/unord/unord.multimap/types.pass.cpp
index 5e7e1451b..2cb74a154 100644
--- a/test/std/containers/unord/unord.multimap/types.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/types.pass.cpp
@@ -32,7 +32,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<char, short> C;
@@ -68,4 +68,6 @@ int main()
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
index dadd81765..e15999f18 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -126,4 +126,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
index 3b2b0cba7..191dec98e 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -227,4 +227,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
index cae8605db..5947905a6 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -142,4 +142,6 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
index f91872111..21c791a81 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -291,4 +291,6 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
index 7438bf530..fe288035f 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multimap<int, int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
index 7747aef54..d57016222 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -190,4 +190,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
index 41b5f537d..ebd047184 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -190,4 +190,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
index 3cd4da37e..dea7a4604 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -108,4 +108,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
index 4866dde5d..5a54f61b5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
@@ -44,7 +44,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -71,4 +71,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
index f276bf777..8f677edcb 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
@@ -37,7 +37,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
@@ -64,4 +64,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
index f6b8cb23e..2681710c9 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multimap<int, int, Hash<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
index 43fb0f971..aba32bfeb 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -251,4 +251,6 @@ int main()
         assert(!(c.get_allocator() == A()));
     }
 #endif // TEST_STD_VER > 11
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
index 37bf73b5c..194daf9f9 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -141,4 +141,6 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
index 9fbc5893f..4613e3ca5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -143,4 +143,6 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
index 398103dee..582b68b94 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -146,4 +146,6 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
index 2f81c2a01..9019d9221 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -207,4 +207,6 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
index 4bfc4d3b7..bfa2327e5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -221,4 +221,6 @@ int main()
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
index 2b711513b..d99c2ad9d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, std::string> P;
@@ -289,4 +289,6 @@ int main()
 
         assert(c0.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
index 649dfd94b..e6f7f4c99 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
@@ -43,7 +43,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
@@ -70,4 +70,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
index c1f6d3143..68ec2600a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
@@ -40,7 +40,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -67,4 +67,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
index 3158236a4..4b916fa41 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -262,4 +262,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
index 731207ef6..aa45e0747 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -148,4 +148,6 @@ int main()
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
index a009d1372..ee9de7a4e 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -151,4 +151,6 @@ int main()
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
index b6548bcc5..54c1f1e9d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -153,4 +153,6 @@ int main()
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
index 288ad6dd3..68181d714 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -217,4 +217,6 @@ int main()
         assert(c.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
index 284618117..122e3aec3 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
index 3c8c46bab..9b58de89d 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
index b299639ee..8dceccf59 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -70,4 +70,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
index 2507e5e8f..5d32ec29b 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -72,4 +72,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
index d9c6a60df..254d89d99 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -96,4 +96,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
index 2db684a52..71c3c57c2 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -60,4 +60,6 @@ int main()
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
index aa38084df..1a20fb876 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, Emplaceable> C;
@@ -68,4 +68,6 @@ int main()
         assert(r->first == 5);
         assert(r->second == Emplaceable(6, 7));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
index 3729b9e5f..ef2904f36 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
@@ -25,7 +25,7 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, Emplaceable> C;
@@ -88,4 +88,6 @@ int main()
         assert(r->first == 3);
         LIBCPP_ASSERT(r->second == Emplaceable(5, 6));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
index 044425256..5ab975077 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
@@ -30,7 +30,7 @@ struct TemplateConstructor
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -143,4 +143,6 @@ int main()
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
index 4986848cd..30fae95f7 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -31,8 +31,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
index 035a796e9..3c0418497 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -34,8 +34,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
index 8f38b65ef..6c3a2cf38 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
index 7d6a7794a..6b0ea3528 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
index 2502f123d..0b53c1cdf 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
index a098f2a66..7cea5e789 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
index 7a94e3489..5e19c970a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
@@ -37,7 +37,7 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -385,4 +385,6 @@ int main()
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
index 46ca4b40d..50f058422 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -176,4 +176,6 @@ int main()
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
index b3ecc3556..a06aca774 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::unordered_multimap<int, int>;
@@ -63,4 +63,6 @@ int main()
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
index fb27c1434..272d5acfb 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multimap<int, int> m =
@@ -73,4 +73,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
index 855b5ea61..73fe6b49b 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -19,8 +19,10 @@
 #include "container_test_types.h"
 #include "../../../map_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMultimapInsert<TCT::unordered_multimap<> >();
   testMultimapInsertHint<TCT::unordered_multimap<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
index 112af3ca4..8eaa69509 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
@@ -51,7 +51,7 @@ void do_insert_const_lvalue_test()
     assert(r->second == 4);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
 #if TEST_STD_VER >= 11
@@ -61,4 +61,6 @@ int main()
         do_insert_const_lvalue_test<C>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
index b21adc888..83cf7b86a 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -56,7 +56,7 @@ void do_insert_const_lvalue_test()
     assert(r->second == 4);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
 #if TEST_STD_VER >= 11
@@ -79,4 +79,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
index 1485e2a83..2993fe757 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
@@ -28,7 +28,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<double, int> C;
@@ -173,4 +173,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
index a707f77c5..3a3f98785 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -117,4 +117,6 @@ int main()
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
index bbaf6aac0..fd1cfa114 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
@@ -67,10 +67,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multimap<int, int> m;
     test(m);
     std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
index ae36abb92..70d207551 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
@@ -53,10 +53,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multimap<int, int> m;
     test(m);
     std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
index 4d0f37dbb..333392af9 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -118,4 +118,6 @@ int main()
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
index 58bb72379..92b91b07c 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
@@ -24,7 +24,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<double, int> C;
@@ -152,4 +152,6 @@ int main()
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
index 0f590972f..1ce1c8361 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_hasher
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multimap<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -153,4 +153,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
index 8b0b8a498..3e15211d5 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -40,4 +40,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
index 6162cb2ff..971fff793 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
@@ -118,7 +118,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -187,4 +187,6 @@ int main()
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
index 7b639ef55..406978241 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -579,4 +579,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
index 1ff880b4e..6183761a3 100644
--- a/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_set>
 
-int main()
+int main(int, char**)
 {
     std::unordered_multiset<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/bucket.pass.cpp b/test/std/containers/unord/unord.multiset/bucket.pass.cpp
index a0837f9fd..4aeb84933 100644
--- a/test/std/containers/unord/unord.multiset/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -73,4 +73,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp b/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
index b6f734961..8f389ebc2 100644
--- a/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -70,4 +70,6 @@ int main()
         assert(c.bucket_count() >= 8);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp b/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
index 78e8c6826..99b76972a 100644
--- a/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -81,4 +81,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/clear.pass.cpp b/test/std/containers/unord/unord.multiset/clear.pass.cpp
index 449de3520..01ff04593 100644
--- a/test/std/containers/unord/unord.multiset/clear.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/clear.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -59,4 +59,6 @@ int main()
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/count.pass.cpp b/test/std/containers/unord/unord.multiset/count.pass.cpp
index 2eb50539b..40cef2af2 100644
--- a/test/std/containers/unord/unord.multiset/count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -66,4 +66,6 @@ int main()
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
index 7f82cf65c..8da630233 100644
--- a/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -50,8 +50,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
index 305a76f24..8bc1e5c16 100644
--- a/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
index e12e3cefb..fbf40ca6e 100644
--- a/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
index 51ccf32ae..53c9c9bd5 100644
--- a/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/emplace.pass.cpp b/test/std/containers/unord/unord.multiset/emplace.pass.cpp
index efbaa35aa..67c5d1642 100644
--- a/test/std/containers/unord/unord.multiset/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<Emplaceable> C;
@@ -58,4 +58,6 @@ int main()
         assert(c.size() == 3);
         assert(*r == Emplaceable(5, 6));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp b/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
index 715b77425..61f06edd4 100644
--- a/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
@@ -24,7 +24,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<Emplaceable> C;
@@ -61,4 +61,6 @@ int main()
         assert(c.size() == 3);
         assert(*r == Emplaceable(5, 6));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/empty.fail.cpp b/test/std/containers/unord/unord.multiset/empty.fail.cpp
index 1aeffd599..449b2116a 100644
--- a/test/std/containers/unord/unord.multiset/empty.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_multiset<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/empty.pass.cpp b/test/std/containers/unord/unord.multiset/empty.pass.cpp
index f96e944a3..078f95f56 100644
--- a/test/std/containers/unord/unord.multiset/empty.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multiset<int> M;
@@ -42,4 +42,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/eq.pass.cpp b/test/std/containers/unord/unord.multiset/eq.pass.cpp
index 6681e05ee..761ad7051 100644
--- a/test/std/containers/unord/unord.multiset/eq.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/eq.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -176,4 +176,6 @@ int main()
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp b/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
index 77bfb557b..ddfd77e18 100644
--- a/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -86,4 +86,6 @@ int main()
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
index c3da35a48..a148f65b1 100644
--- a/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -86,4 +86,6 @@ int main()
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
index daa39956a..0a92f7d06 100644
--- a/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
@@ -28,7 +28,7 @@ struct TemplateConstructor
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -96,4 +96,6 @@ int main()
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/erase_if.pass.cpp b/test/std/containers/unord/unord.multiset/erase_if.pass.cpp
index 761b94e1d..bd587473c 100644
--- a/test/std/containers/unord/unord.multiset/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_if.pass.cpp
@@ -79,7 +79,7 @@ void test()
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_multiset<int>>();
     test<std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
@@ -87,4 +87,6 @@ int main()
 
     test<std::unordered_multiset<long>>();
     test<std::unordered_multiset<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
index 742fe2bc2..073043f5a 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -30,8 +30,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
index 9a6e09d47..28768eaf5 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
index dac9ac6af..0a9853d66 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
index f2eb5277e..cc1ec0096 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
index a3e2d8cce..a1de8cb7c 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
index 41cc1f873..a82ecfc3c 100644
--- a/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -31,8 +31,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.multiset/erase_key.pass.cpp b/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
index 1ed8cd704..ba7248d74 100644
--- a/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_key.pass.cpp
@@ -36,7 +36,7 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -172,4 +172,6 @@ int main()
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/erase_range.pass.cpp b/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
index 8c1f8479a..c6bb4b597 100644
--- a/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/erase_range.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -91,4 +91,6 @@ int main()
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp b/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
index e0a0f96b9..01994120c 100644
--- a/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::unordered_multiset<int>;
@@ -56,4 +56,6 @@ int main()
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/extract_key.pass.cpp b/test/std/containers/unord/unord.multiset/extract_key.pass.cpp
index 78d763ff5..380b39f85 100644
--- a/test/std/containers/unord/unord.multiset/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/extract_key.pass.cpp
@@ -43,7 +43,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multiset<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/find_const.pass.cpp b/test/std/containers/unord/unord.multiset/find_const.pass.cpp
index 8d6da1945..efa8bfc12 100644
--- a/test/std/containers/unord/unord.multiset/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/find_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -64,4 +64,6 @@ int main()
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp b/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
index 713f1ebe1..4eeb8ac6a 100644
--- a/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -64,4 +64,6 @@ int main()
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/incomplete.pass.cpp b/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
index 67fe1a9c0..0aeb246ca 100644
--- a/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/incomplete.pass.cpp
@@ -32,6 +32,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
index 90666e0c1..8200dc2fc 100644
--- a/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
@@ -46,7 +46,7 @@ void do_insert_const_lvalue_test()
     assert(*r == 5.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multiset<double> >();
 #if TEST_STD_VER >= 11
@@ -56,4 +56,6 @@ int main()
         do_insert_const_lvalue_test<C>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
index bc14294c3..d7474f24e 100644
--- a/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
@@ -18,8 +18,10 @@
 #include "container_test_types.h"
 #include "../../set_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMultisetInsert<TCT::unordered_multiset<> >();
   testMultisetEmplace<TCT::unordered_multiset<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
index 283368091..ede013ef9 100644
--- a/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
@@ -51,7 +51,7 @@ void do_insert_hint_const_lvalue_test()
     assert(*r == 5.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_multiset<double> >();
 #if TEST_STD_VER >= 11
@@ -74,4 +74,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
index 39c04a1b6..ab5302462 100644
--- a/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<double> C;
@@ -115,4 +115,6 @@ int main()
         assert(*r == 5);
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_init.pass.cpp b/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
index 60d58c0d2..4467c74b4 100644
--- a/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_init.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -65,4 +65,6 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp b/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
index 0a06fe6b9..c660ab22d 100644
--- a/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
@@ -66,10 +66,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multiset<int> m;
     test(m);
     std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
index 364346805..e95dd31e3 100644
--- a/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
@@ -49,10 +49,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multiset<int> m;
     test(m);
     std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_range.pass.cpp b/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
index 2487a2d4b..b8742f520 100644
--- a/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -66,4 +66,6 @@ int main()
         assert(c.count(4) == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
index 056288c78..1bec2b7e6 100644
--- a/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<double> C;
@@ -111,4 +111,6 @@ int main()
         assert(*r == 5);
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/iterators.fail.cpp b/test/std/containers/unord/unord.multiset/iterators.fail.cpp
index 3cf31d52c..2c282fdba 100644
--- a/test/std/containers/unord/unord.multiset/iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/iterators.fail.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -65,4 +65,6 @@ int main()
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/iterators.pass.cpp b/test/std/containers/unord/unord.multiset/iterators.pass.cpp
index b6147e9c6..2c0cd496d 100644
--- a/test/std/containers/unord/unord.multiset/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/iterators.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -125,4 +125,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/load_factor.pass.cpp b/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
index ece450ceb..bb3350e86 100644
--- a/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/load_factor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -71,4 +71,6 @@ int main()
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp b/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
index a27353414..d6f1a55fd 100644
--- a/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -259,4 +259,6 @@ int main()
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp b/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
index b63a94ae1..5aa657563 100644
--- a/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -496,4 +496,6 @@ int main()
         assert(std::distance(i, j) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
index c503a3537..7fb76c41c 100644
--- a/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -34,4 +34,6 @@ int main()
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp b/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
index 1a6b1335a..c89aa6d33 100644
--- a/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -62,4 +62,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/max_size.pass.cpp b/test/std/containers/unord/unord.multiset/max_size.pass.cpp
index a6a7dae25..d08cdb622 100644
--- a/test/std/containers/unord/unord.multiset/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -50,4 +50,6 @@ int main()
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/merge.pass.cpp b/test/std/containers/unord/unord.multiset/merge.pass.cpp
index 1082f4990..e951b33d2 100644
--- a/test/std/containers/unord/unord.multiset/merge.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_hasher
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multiset<int> src{1, 3, 5};
@@ -150,4 +150,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/rehash.pass.cpp b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
index 38691f200..8c6699b18 100644
--- a/test/std/containers/unord/unord.multiset/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
@@ -36,7 +36,7 @@ void test(const C& c)
     assert(c.count(4) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -99,4 +99,6 @@ int main()
         test(c);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/reserve.pass.cpp b/test/std/containers/unord/unord.multiset/reserve.pass.cpp
index 079786689..54eada5a7 100644
--- a/test/std/containers/unord/unord.multiset/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/reserve.pass.cpp
@@ -45,7 +45,7 @@ void reserve_invariant(size_t n) // LWG #2156
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -103,4 +103,6 @@ int main()
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/scary.pass.cpp b/test/std/containers/unord/unord.multiset/scary.pass.cpp
index 7ef4a513f..670c6406a 100644
--- a/test/std/containers/unord/unord.multiset/scary.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <unordered_set>
 
-int main()
+int main(int, char**)
 {
     typedef std::unordered_set<int> M1;
     typedef std::unordered_multiset<int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/size.pass.cpp b/test/std/containers/unord/unord.multiset/size.pass.cpp
index 3aae7dd53..12a4733cc 100644
--- a/test/std/containers/unord/unord.multiset/size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multiset<int> M;
@@ -58,4 +58,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/swap_member.pass.cpp b/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
index 2937e444e..bad8df9d9 100644
--- a/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/types.pass.cpp b/test/std/containers/unord/unord.multiset/types.pass.cpp
index 8b246778d..81f8334c2 100644
--- a/test/std/containers/unord/unord.multiset/types.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/types.pass.cpp
@@ -31,7 +31,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<short> C;
@@ -65,4 +65,6 @@ int main()
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
index e446fa65e..2a3b867b5 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -106,4 +106,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
index c90a0106a..1fcd71002 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -209,4 +209,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
index cf286319d..795370c44 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -93,4 +93,6 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
index 00adca3c4..1ed77851c 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -263,4 +263,6 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
index b1e161b42..4b8d55cac 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multiset<int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
index e3a57fa55..f3ca15241 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -168,4 +168,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
index aac5fde6a..4e99490ea 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -122,4 +122,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
index 85fc84896..bb762b576 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -104,4 +104,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
index 71661d5ea..4acda3255 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
@@ -44,7 +44,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -71,4 +71,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
index c65c0f15e..1d963b6be 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
@@ -37,7 +37,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<MoveOnly> C;
@@ -64,4 +64,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
index 97b031ab8..9e24ce2ec 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multiset<int, Hash<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
index 7b3d996f7..d8fc0c002 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -160,4 +160,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif // TEST_STD_VER > 11
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
index 475f2664d..bda874ce5 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -94,4 +94,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
index de5f6ae17..5c81a3461 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -97,4 +97,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
index cffd9d55e..c77d85057 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -99,4 +99,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
index 57df30145..8a26b3948 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -101,4 +101,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
index 670102be4..196044f21 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -171,4 +171,6 @@ int main()
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
index 5e822b458..eb567a9da 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int P;
@@ -202,4 +202,6 @@ int main()
 
         assert(c0.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
index 702125b66..4b0051a9b 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
@@ -43,7 +43,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<MoveOnly> C;
@@ -70,4 +70,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
index 03f61a504..3941940f9 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
@@ -40,7 +40,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -67,4 +67,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
index 5d729ec49..953e702a6 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -166,4 +166,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
index d423c8864..2b7e911cd 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -100,4 +100,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
index 84f7d5a13..1b3944130 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -103,4 +103,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
index 93d92257c..d83555f57 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -105,4 +105,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
index e8e425f2d..10c69c27a 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -108,4 +108,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
index d115f98fe..45d67f33a 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -62,4 +62,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
index 2e1c749f2..ba32ec370 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -62,4 +62,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
index 3868b3720..47d0867f0 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -66,4 +66,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
index eebcc14a6..f9cc2503b 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -68,4 +68,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
index ab2ac6ee5..8e25bf00e 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -70,4 +70,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
index 3ad54c42f..a546d0d7d 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -39,4 +39,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
index 73c3cc66a..3586e8d5b 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
@@ -118,7 +118,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<MoveOnly> C;
@@ -186,4 +186,6 @@ int main()
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
index 60826ffd1..706c995f3 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp b/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
index 6286031e5..0d1341e69 100644
--- a/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
+++ b/test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_set>
 
-int main()
+int main(int, char**)
 {
     std::unordered_set<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/bucket.pass.cpp b/test/std/containers/unord/unord.set/bucket.pass.cpp
index 58d77e3d5..2215b9949 100644
--- a/test/std/containers/unord/unord.set/bucket.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -72,4 +72,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/bucket_count.pass.cpp b/test/std/containers/unord/unord.set/bucket_count.pass.cpp
index 3dadbd21a..3a1a78cb3 100644
--- a/test/std/containers/unord/unord.set/bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -68,4 +68,6 @@ int main()
         assert(c.bucket_count() >= 8);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/bucket_size.pass.cpp b/test/std/containers/unord/unord.set/bucket_size.pass.cpp
index e37e047af..6ca89d572 100644
--- a/test/std/containers/unord/unord.set/bucket_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/bucket_size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -76,4 +76,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/clear.pass.cpp b/test/std/containers/unord/unord.set/clear.pass.cpp
index abaaec3e2..ab04cdd91 100644
--- a/test/std/containers/unord/unord.set/clear.pass.cpp
+++ b/test/std/containers/unord/unord.set/clear.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -58,4 +58,6 @@ int main()
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/count.pass.cpp b/test/std/containers/unord/unord.set/count.pass.cpp
index 97694684d..971e126fd 100644
--- a/test/std/containers/unord/unord.set/count.pass.cpp
+++ b/test/std/containers/unord/unord.set/count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -65,4 +65,6 @@ int main()
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp b/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
index ef58e2561..8420de60d 100644
--- a/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -50,8 +50,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp b/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
index 10692fa49..14dccf97d 100644
--- a/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp b/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
index e3a04f6a9..ac066af7f 100644
--- a/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp b/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
index 57dfda6fc..a1595cd36 100644
--- a/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
+++ b/test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/emplace.pass.cpp b/test/std/containers/unord/unord.set/emplace.pass.cpp
index 32e6e3487..6616aa51c 100644
--- a/test/std/containers/unord/unord.set/emplace.pass.cpp
+++ b/test/std/containers/unord/unord.set/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<Emplaceable> C;
@@ -64,4 +64,6 @@ int main()
         assert(*r.first == Emplaceable(5, 6));
         assert(!r.second);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/emplace_hint.pass.cpp b/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
index 1bab8d9c3..55b3ccbc9 100644
--- a/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
+++ b/test/std/containers/unord/unord.set/emplace_hint.pass.cpp
@@ -24,7 +24,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<Emplaceable> C;
@@ -61,4 +61,6 @@ int main()
         assert(c.size() == 2);
         assert(*r == Emplaceable(5, 6));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/empty.fail.cpp b/test/std/containers/unord/unord.set/empty.fail.cpp
index f683f23a7..11273f44f 100644
--- a/test/std/containers/unord/unord.set/empty.fail.cpp
+++ b/test/std/containers/unord/unord.set/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_set<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/empty.pass.cpp b/test/std/containers/unord/unord.set/empty.pass.cpp
index 3656e60c0..ce9cfdcf5 100644
--- a/test/std/containers/unord/unord.set/empty.pass.cpp
+++ b/test/std/containers/unord/unord.set/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_set<int> M;
@@ -42,4 +42,6 @@ int main()
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/eq.pass.cpp b/test/std/containers/unord/unord.set/eq.pass.cpp
index 82737f1ba..5362f57f4 100644
--- a/test/std/containers/unord/unord.set/eq.pass.cpp
+++ b/test/std/containers/unord/unord.set/eq.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -155,4 +155,6 @@ int main()
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/equal_range_const.pass.cpp b/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
index 587971b74..9489deaf2 100644
--- a/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/equal_range_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -77,4 +77,6 @@ int main()
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp b/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
index 923c1764d..6713dbd91 100644
--- a/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -77,4 +77,6 @@ int main()
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp b/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
index 84f4f81d1..3d9cfe683 100644
--- a/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
@@ -28,7 +28,7 @@ struct TemplateConstructor
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -94,4 +94,6 @@ int main()
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/erase_if.pass.cpp b/test/std/containers/unord/unord.set/erase_if.pass.cpp
index 2b5f8f6c8..cbd2ebb1a 100644
--- a/test/std/containers/unord/unord.set/erase_if.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_if.pass.cpp
@@ -69,7 +69,7 @@ void test()
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_set<int>>();
     test<std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
@@ -77,4 +77,6 @@ int main()
 
     test<std::unordered_set<long>>();
     test<std::unordered_set<double>>();
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
index 3bf6282cc..a65086ee8 100644
--- a/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -30,8 +30,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
index 34f8a6076..c7f64da35 100644
--- a/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -33,8 +33,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
index bcf3df82b..002a24bf1 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
index 1a222d91b..59bf0cc33 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
index 83cc5d558..c522fce26 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp b/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
index 218d50137..a7c3c0020 100644
--- a/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -31,8 +31,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/containers/unord/unord.set/erase_key.pass.cpp b/test/std/containers/unord/unord.set/erase_key.pass.cpp
index ea80e2d01..912a4ae6b 100644
--- a/test/std/containers/unord/unord.set/erase_key.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_key.pass.cpp
@@ -36,7 +36,7 @@ bool only_deletions ( const Unordered &whole, const Unordered &part ) {
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -171,4 +171,6 @@ int main()
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/erase_range.pass.cpp b/test/std/containers/unord/unord.set/erase_range.pass.cpp
index 11908637b..907063c6a 100644
--- a/test/std/containers/unord/unord.set/erase_range.pass.cpp
+++ b/test/std/containers/unord/unord.set/erase_range.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -90,4 +90,6 @@ int main()
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/extract_iterator.pass.cpp b/test/std/containers/unord/unord.set/extract_iterator.pass.cpp
index e03e11ff6..03dfcc602 100644
--- a/test/std/containers/unord/unord.set/extract_iterator.pass.cpp
+++ b/test/std/containers/unord/unord.set/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@ void test(Container& c)
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::unordered_set<int>;
@@ -56,4 +56,6 @@ int main()
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/extract_key.pass.cpp b/test/std/containers/unord/unord.set/extract_key.pass.cpp
index 9a6123714..b2a6f0493 100644
--- a/test/std/containers/unord/unord.set/extract_key.pass.cpp
+++ b/test/std/containers/unord/unord.set/extract_key.pass.cpp
@@ -43,7 +43,7 @@ void test(Container& c, KeyTypeIter first, KeyTypeIter last)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_set<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@ int main()
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/find_const.pass.cpp b/test/std/containers/unord/unord.set/find_const.pass.cpp
index e46e3d5f1..f226a6960 100644
--- a/test/std/containers/unord/unord.set/find_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/find_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -63,4 +63,6 @@ int main()
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/find_non_const.pass.cpp b/test/std/containers/unord/unord.set/find_non_const.pass.cpp
index bbd37754e..4b24b2f44 100644
--- a/test/std/containers/unord/unord.set/find_non_const.pass.cpp
+++ b/test/std/containers/unord/unord.set/find_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -63,4 +63,6 @@ int main()
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/incomplete.pass.cpp b/test/std/containers/unord/unord.set/incomplete.pass.cpp
index 12c95353c..b77f679fe 100644
--- a/test/std/containers/unord/unord.set/incomplete.pass.cpp
+++ b/test/std/containers/unord/unord.set/incomplete.pass.cpp
@@ -32,6 +32,8 @@ struct A {
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp b/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
index fffd108a7..34905e3c8 100644
--- a/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -21,8 +21,10 @@
 #include "../../set_allocator_requirement_test_templates.h"
 
 
-int main()
+int main(int, char**)
 {
   testSetInsert<TCT::unordered_set<> >();
   testSetEmplace<TCT::unordered_set<> >();
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
index 820ac6e90..097b221a6 100644
--- a/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
@@ -50,7 +50,7 @@ void do_insert_const_lvalue_test()
     assert(r.second);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11
@@ -60,4 +60,6 @@ int main()
         do_insert_const_lvalue_test<C>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
index 3ca654764..e3765ca02 100644
--- a/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
@@ -51,7 +51,7 @@ void do_insert_hint_const_lvalue_test()
     assert(*r == 5.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11
@@ -74,4 +74,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
index f4a38dcfb..071708e1e 100644
--- a/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<double> C;
@@ -115,4 +115,6 @@ int main()
         assert(*r == 5);
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_init.pass.cpp b/test/std/containers/unord/unord.set/insert_init.pass.cpp
index 2af3d3732..c60fcb16b 100644
--- a/test/std/containers/unord/unord.set/insert_init.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_init.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -65,4 +65,6 @@ int main()
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_node_type.pass.cpp b/test/std/containers/unord/unord.set/insert_node_type.pass.cpp
index 8eed65865..f41c93685 100644
--- a/test/std/containers/unord/unord.set/insert_node_type.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_node_type.pass.cpp
@@ -73,10 +73,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_set<int> m;
     test(m);
     std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp b/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
index bf8c12776..ae5e8976e 100644
--- a/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
@@ -51,10 +51,12 @@ void test(Container& c)
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_set<int> m;
     test(m);
     std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_range.pass.cpp b/test/std/containers/unord/unord.set/insert_range.pass.cpp
index d0c4d7e85..cb365483a 100644
--- a/test/std/containers/unord/unord.set/insert_range.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -66,4 +66,6 @@ int main()
         assert(c.count(4) == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
index 75342b7c3..9edab2740 100644
--- a/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
+++ b/test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<double> C;
@@ -127,4 +127,6 @@ int main()
         assert(r.second);
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/iterators.fail.cpp b/test/std/containers/unord/unord.set/iterators.fail.cpp
index 8ded4e023..de5f88e79 100644
--- a/test/std/containers/unord/unord.set/iterators.fail.cpp
+++ b/test/std/containers/unord/unord.set/iterators.fail.cpp
@@ -22,7 +22,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -63,4 +63,6 @@ int main()
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/iterators.pass.cpp b/test/std/containers/unord/unord.set/iterators.pass.cpp
index 73b1a4c54..eb8459101 100644
--- a/test/std/containers/unord/unord.set/iterators.pass.cpp
+++ b/test/std/containers/unord/unord.set/iterators.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -125,4 +125,6 @@ int main()
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/load_factor.pass.cpp b/test/std/containers/unord/unord.set/load_factor.pass.cpp
index 06d17dc90..c5857b7b4 100644
--- a/test/std/containers/unord/unord.set/load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.set/load_factor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -71,4 +71,6 @@ int main()
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/local_iterators.fail.cpp b/test/std/containers/unord/unord.set/local_iterators.fail.cpp
index b7c3d9b6b..7bacd2f6f 100644
--- a/test/std/containers/unord/unord.set/local_iterators.fail.cpp
+++ b/test/std/containers/unord/unord.set/local_iterators.fail.cpp
@@ -22,7 +22,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -257,4 +257,6 @@ int main()
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/local_iterators.pass.cpp b/test/std/containers/unord/unord.set/local_iterators.pass.cpp
index 0797c1ec8..ad3de5b0a 100644
--- a/test/std/containers/unord/unord.set/local_iterators.pass.cpp
+++ b/test/std/containers/unord/unord.set/local_iterators.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -384,4 +384,6 @@ int main()
         assert(*i == 4);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp b/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
index 88471bbaf..121147a08 100644
--- a/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -34,4 +34,6 @@ int main()
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/max_load_factor.pass.cpp b/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
index 35028a827..ac345a1d4 100644
--- a/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_load_factor.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -62,4 +62,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/max_size.pass.cpp b/test/std/containers/unord/unord.set/max_size.pass.cpp
index 5ec2af75b..aeb1354da 100644
--- a/test/std/containers/unord/unord.set/max_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -46,4 +46,6 @@ int main()
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/merge.pass.cpp b/test/std/containers/unord/unord.set/merge.pass.cpp
index 91dd476d4..4a11867ed 100644
--- a/test/std/containers/unord/unord.set/merge.pass.cpp
+++ b/test/std/containers/unord/unord.set/merge.pass.cpp
@@ -49,7 +49,7 @@ struct throw_hasher
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_set<int> src{1, 3, 5};
@@ -150,4 +150,5 @@ int main()
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
diff --git a/test/std/containers/unord/unord.set/rehash.pass.cpp b/test/std/containers/unord/unord.set/rehash.pass.cpp
index c373b1632..e45327ad7 100644
--- a/test/std/containers/unord/unord.set/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.set/rehash.pass.cpp
@@ -36,7 +36,7 @@ void test(const C& c)
     assert(c.count(4) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -99,4 +99,6 @@ int main()
         test(c);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/reserve.pass.cpp b/test/std/containers/unord/unord.set/reserve.pass.cpp
index a852f1022..7ea358e88 100644
--- a/test/std/containers/unord/unord.set/reserve.pass.cpp
+++ b/test/std/containers/unord/unord.set/reserve.pass.cpp
@@ -45,7 +45,7 @@ void reserve_invariant(size_t n) // LWG #2156
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -103,4 +103,6 @@ int main()
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/size.pass.cpp b/test/std/containers/unord/unord.set/size.pass.cpp
index e3e488461..f7967fcd5 100644
--- a/test/std/containers/unord/unord.set/size.pass.cpp
+++ b/test/std/containers/unord/unord.set/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_set<int> M;
@@ -58,4 +58,6 @@ int main()
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/swap_member.pass.cpp b/test/std/containers/unord/unord.set/swap_member.pass.cpp
index 9c34e8de9..0877b14f7 100644
--- a/test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ b/test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/types.pass.cpp b/test/std/containers/unord/unord.set/types.pass.cpp
index 7beafedc2..7b1531dc2 100644
--- a/test/std/containers/unord/unord.set/types.pass.cpp
+++ b/test/std/containers/unord/unord.set/types.pass.cpp
@@ -31,7 +31,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<short> C;
@@ -65,4 +65,6 @@ int main()
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
index d6e604d72..920244aae 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -106,4 +106,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
index 083ebda3f..109529542 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -184,4 +184,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
index 515022124..bbb2045cb 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -93,4 +93,6 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
index 9c8d055a9..15741254d 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -210,4 +210,6 @@ int main()
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
index 21cd61458..0638027fd 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_set<int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
index 652f2e4a4..179e6e473 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -144,4 +144,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
index 800f4f36a..970da0877 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -106,4 +106,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
index 52cda0692..1fa2932e5 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -104,4 +104,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
index 533c10df4..5d6508d46 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
@@ -44,7 +44,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -71,4 +71,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
index 7041c8263..2225469e9 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
@@ -37,7 +37,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<MoveOnly> C;
@@ -64,4 +64,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
index 0ddae6671..92550a096 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@ private:
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_set<int, Hash<int> > m;
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
index 1550727d8..8bf0453c3 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
   {
         typedef std::unordered_set<int,
@@ -160,4 +160,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
index 54b6fbd71..3e58ce928 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -94,4 +94,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
index d7330c3bd..3761cc33d 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -97,4 +97,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
index 1741320bc..7123e3415 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -99,4 +99,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
index ac1369169..94aa74f24 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -101,4 +101,6 @@ int main()
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
index 0bbf312bd..5b599ae71 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -171,4 +171,6 @@ int main()
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
index 03567db22..bc6629acd 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int P;
@@ -152,4 +152,6 @@ int main()
 
         assert(c0.empty());
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
index c91d972f3..dba99837d 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
@@ -43,7 +43,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<MoveOnly> C;
@@ -70,4 +70,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
index 86a058b07..49802f689 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
@@ -40,7 +40,7 @@ struct some_hash
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -67,4 +67,6 @@ int main()
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
index 182ce8bee..dfa46ec56 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -167,4 +167,6 @@ int main()
 
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
index 0c90055eb..1115044e0 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -100,4 +100,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
index 3805b7f32..2acbb2d18 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -103,4 +103,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
index 3fc872236..245e12476 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -105,4 +105,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
index 8d73e92db..002466496 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -108,4 +108,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
index 4ed509633..da3dc1855 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
@@ -23,7 +23,7 @@
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -42,4 +42,6 @@ int main()
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
index d63770529..12ba6201a 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -62,4 +62,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
index 4ded899f6..60134b7fa 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -66,4 +66,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
index 36f104dfb..49e12ea29 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -68,4 +68,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
index bb14b27a9..43eb1f717 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -70,4 +70,6 @@ int main()
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
index 5ea0aa38f..f14f0ddeb 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -39,4 +39,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
index 61371306e..40bf1894d 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
@@ -118,7 +118,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<MoveOnly> C;
@@ -186,4 +186,6 @@ int main()
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp b/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
index aad68658a..8f1d9f0c3 100644
--- a/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@ int main()
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/array.fail.cpp b/test/std/containers/views/span.cons/array.fail.cpp
index 7e9d85dcd..f61649771 100644
--- a/test/std/containers/views/span.cons/array.fail.cpp
+++ b/test/std/containers/views/span.cons/array.fail.cpp
@@ -34,7 +34,7 @@ const          int  carr[] = {4,5,6};
       volatile int  varr[] = {7,8,9};
 const volatile int cvarr[] = {1,3,5};
 
-int main ()
+int main(int, char**)
 {
 //  Size wrong
     {
@@ -68,4 +68,6 @@ int main ()
     std::span<      volatile int,3> s6{ carr};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     std::span<      volatile int,3> s7{cvarr};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/array.pass.cpp b/test/std/containers/views/span.cons/array.pass.cpp
index d9d1029b6..5ac7e1a4a 100644
--- a/test/std/containers/views/span.cons/array.pass.cpp
+++ b/test/std/containers/views/span.cons/array.pass.cpp
@@ -105,7 +105,7 @@ void testRuntimeSpan()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -119,4 +119,6 @@ int main ()
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/assign.pass.cpp b/test/std/containers/views/span.cons/assign.pass.cpp
index ea6028ad0..3f8d5f418 100644
--- a/test/std/containers/views/span.cons/assign.pass.cpp
+++ b/test/std/containers/views/span.cons/assign.pass.cpp
@@ -37,7 +37,7 @@ constexpr int carr3[] = {7,8};
 std::string strs[] = {"ABC", "DEF", "GHI"};
 
 
-int main ()
+int main(int, char**)
 {
 
 //  constexpr dynamically sized assignment
@@ -289,4 +289,6 @@ int main ()
             for (size_t j = i; j < std::size(spans); ++j)
                 assert((doAssign(spans[i], spans[j])));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/container.fail.cpp b/test/std/containers/views/span.cons/container.fail.cpp
index cfffa57a1..d0fb5656d 100644
--- a/test/std/containers/views/span.cons/container.fail.cpp
+++ b/test/std/containers/views/span.cons/container.fail.cpp
@@ -63,7 +63,7 @@ private:
 };
 
 
-int main ()
+int main(int, char**)
 {
 
 //  Making non-const spans from const sources (a temporary binds to `const &`)
@@ -129,4 +129,6 @@ int main ()
     std::span<      volatile int,1> s7{cv}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
     }
 
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/container.pass.cpp b/test/std/containers/views/span.cons/container.pass.cpp
index 4e9001bff..07aac9229 100644
--- a/test/std/containers/views/span.cons/container.pass.cpp
+++ b/test/std/containers/views/span.cons/container.pass.cpp
@@ -117,7 +117,7 @@ void testRuntimeSpan()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -131,4 +131,6 @@ int main ()
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/copy.pass.cpp b/test/std/containers/views/span.cons/copy.pass.cpp
index 1ccb679ce..2ad1cded2 100644
--- a/test/std/containers/views/span.cons/copy.pass.cpp
+++ b/test/std/containers/views/span.cons/copy.pass.cpp
@@ -42,7 +42,7 @@ void testCV ()
 }
 
 
-int main ()
+int main(int, char**)
 {
     constexpr int carr[] = {1,2,3};
 
@@ -67,4 +67,6 @@ int main ()
     testCV<const          int>();
     testCV<      volatile int>();
     testCV<const volatile int>();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/deduct.pass.cpp b/test/std/containers/views/span.cons/deduct.pass.cpp
index 7c5338836..188463bc3 100644
--- a/test/std/containers/views/span.cons/deduct.pass.cpp
+++ b/test/std/containers/views/span.cons/deduct.pass.cpp
@@ -40,7 +40,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main ()
+int main(int, char**)
 {
     {
     int arr[] = {1,2,3};
@@ -83,4 +83,6 @@ int main ()
     assert((size_t)s.size() == str.size());
     assert((std::equal(s.begin(), s.end(), std::begin(s), std::end(s))));
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/default.fail.cpp b/test/std/containers/views/span.cons/default.fail.cpp
index 309f7180c..24ff77477 100644
--- a/test/std/containers/views/span.cons/default.fail.cpp
+++ b/test/std/containers/views/span.cons/default.fail.cpp
@@ -22,10 +22,12 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::span<int, 2> s; // expected-error-re@span:* {{static_assert failed{{( due to requirement '2[LL]{0,2} == 0')?}} "Can't default construct a statically sized span with size > 0"}}
 
 //  TODO: This is what I want:
 // eXpected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/default.pass.cpp b/test/std/containers/views/span.cons/default.pass.cpp
index 431b7e90b..867026bd9 100644
--- a/test/std/containers/views/span.cons/default.pass.cpp
+++ b/test/std/containers/views/span.cons/default.pass.cpp
@@ -64,7 +64,7 @@ void testRuntimeSpan()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -78,4 +78,6 @@ int main ()
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/ptr_len.fail.cpp b/test/std/containers/views/span.cons/ptr_len.fail.cpp
index ad63c69b3..d407ae779 100644
--- a/test/std/containers/views/span.cons/ptr_len.fail.cpp
+++ b/test/std/containers/views/span.cons/ptr_len.fail.cpp
@@ -27,7 +27,7 @@ const          int  carr[] = {4,5,6};
       volatile int  varr[] = {7,8,9};
 const volatile int cvarr[] = {1,3,5};
 
-int main ()
+int main(int, char**)
 {
 //  We can't check that the size doesn't match - because that's a runtime property
 //  std::span<int, 2>   s1(arr, 3);
@@ -59,4 +59,6 @@ int main ()
     std::span<      volatile int,3> s6{ carr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     std::span<      volatile int,3> s7{cvarr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/ptr_len.pass.cpp b/test/std/containers/views/span.cons/ptr_len.pass.cpp
index a1a93c71f..2a4b260c8 100644
--- a/test/std/containers/views/span.cons/ptr_len.pass.cpp
+++ b/test/std/containers/views/span.cons/ptr_len.pass.cpp
@@ -95,7 +95,7 @@ void testRuntimeSpan()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -109,4 +109,6 @@ int main ()
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/ptr_ptr.fail.cpp b/test/std/containers/views/span.cons/ptr_ptr.fail.cpp
index 0bda60c3f..9c15ea58c 100644
--- a/test/std/containers/views/span.cons/ptr_ptr.fail.cpp
+++ b/test/std/containers/views/span.cons/ptr_ptr.fail.cpp
@@ -27,7 +27,7 @@ const          int  carr[] = {4,5,6};
       volatile int  varr[] = {7,8,9};
 const volatile int cvarr[] = {1,3,5};
 
-int main ()
+int main(int, char**)
 {
 //  We can't check that the size doesn't match - because that's a runtime property
 //  std::span<int, 2>   s1(arr, arr + 3);
@@ -59,4 +59,6 @@ int main ()
     std::span<      volatile int,3> s6{ carr,  carr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     std::span<      volatile int,3> s7{cvarr, cvarr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/ptr_ptr.pass.cpp b/test/std/containers/views/span.cons/ptr_ptr.pass.cpp
index 1d693e392..15c9f303e 100644
--- a/test/std/containers/views/span.cons/ptr_ptr.pass.cpp
+++ b/test/std/containers/views/span.cons/ptr_ptr.pass.cpp
@@ -95,7 +95,7 @@ void testRuntimeSpan()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -109,4 +109,6 @@ int main ()
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/span.fail.cpp b/test/std/containers/views/span.cons/span.fail.cpp
index 132d1b152..f559b1fb0 100644
--- a/test/std/containers/views/span.cons/span.fail.cpp
+++ b/test/std/containers/views/span.cons/span.fail.cpp
@@ -89,7 +89,7 @@ void checkCV ()
     }
 }
 
-int main ()
+int main(int, char**)
 {
     std::span<int>      sp;
     std::span<int, 0>   sp0;
@@ -100,4 +100,6 @@ int main ()
     std::span<float, 0> s4{sp0};    // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/span.pass.cpp b/test/std/containers/views/span.cons/span.pass.cpp
index 8ace94f5e..74da3fce8 100644
--- a/test/std/containers/views/span.cons/span.pass.cpp
+++ b/test/std/containers/views/span.cons/span.pass.cpp
@@ -121,7 +121,7 @@ bool testConversionSpan()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -138,4 +138,6 @@ int main ()
 //  assert((testConversionSpan<unsigned char, char>()));
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.cons/stdarray.pass.cpp b/test/std/containers/views/span.cons/stdarray.pass.cpp
index a0b37fe8e..03fdd2534 100644
--- a/test/std/containers/views/span.cons/stdarray.pass.cpp
+++ b/test/std/containers/views/span.cons/stdarray.pass.cpp
@@ -96,7 +96,7 @@ void testRuntimeSpan()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -110,4 +110,6 @@ int main ()
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.elem/data.pass.cpp b/test/std/containers/views/span.elem/data.pass.cpp
index ca49eb890..c858a7e11 100644
--- a/test/std/containers/views/span.elem/data.pass.cpp
+++ b/test/std/containers/views/span.elem/data.pass.cpp
@@ -40,7 +40,7 @@ struct A{};
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
 
 //  dynamic size
@@ -117,4 +117,6 @@ int main ()
     testRuntimeSpan(std::span<std::string>(&s, 1), &s);
     testRuntimeSpan(std::span<std::string, 1>(&s, 1), &s);
 
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.elem/op_idx.pass.cpp b/test/std/containers/views/span.elem/op_idx.pass.cpp
index d11032673..c56be7d3e 100644
--- a/test/std/containers/views/span.elem/op_idx.pass.cpp
+++ b/test/std/containers/views/span.elem/op_idx.pass.cpp
@@ -51,7 +51,7 @@ struct A{};
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<const int>(iArr1, 1), 0), "");
 
@@ -115,4 +115,6 @@ int main ()
     std::string s;
     testRuntimeSpan(std::span<std::string>   (&s, 1), 0);
     testRuntimeSpan(std::span<std::string, 1>(&s, 1), 0);
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.iterators/begin.pass.cpp b/test/std/containers/views/span.iterators/begin.pass.cpp
index 0abae63ff..e4532ade5 100644
--- a/test/std/containers/views/span.iterators/begin.pass.cpp
+++ b/test/std/containers/views/span.iterators/begin.pass.cpp
@@ -70,7 +70,7 @@ constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -112,4 +112,6 @@ int main()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.iterators/end.pass.cpp b/test/std/containers/views/span.iterators/end.pass.cpp
index a834804d1..c52c8bc60 100644
--- a/test/std/containers/views/span.iterators/end.pass.cpp
+++ b/test/std/containers/views/span.iterators/end.pass.cpp
@@ -78,7 +78,7 @@ constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -120,4 +120,6 @@ int main()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.iterators/rbegin.pass.cpp b/test/std/containers/views/span.iterators/rbegin.pass.cpp
index 66e1d5ebf..fc7d3c8e0 100644
--- a/test/std/containers/views/span.iterators/rbegin.pass.cpp
+++ b/test/std/containers/views/span.iterators/rbegin.pass.cpp
@@ -71,7 +71,7 @@ constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -113,4 +113,6 @@ int main()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, static_cast<std::ptrdiff_t>(0)));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.iterators/rend.pass.cpp b/test/std/containers/views/span.iterators/rend.pass.cpp
index 7c53cb0be..056fe2a7d 100644
--- a/test/std/containers/views/span.iterators/rend.pass.cpp
+++ b/test/std/containers/views/span.iterators/rend.pass.cpp
@@ -72,7 +72,7 @@ constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -114,4 +114,6 @@ int main()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.objectrep/as_bytes.pass.cpp b/test/std/containers/views/span.objectrep/as_bytes.pass.cpp
index 989b6dc5c..3e6a7d79f 100644
--- a/test/std/containers/views/span.objectrep/as_bytes.pass.cpp
+++ b/test/std/containers/views/span.objectrep/as_bytes.pass.cpp
@@ -45,7 +45,7 @@ void testRuntimeSpan(Span sp)
 struct A{};
 int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
 
-int main ()
+int main(int, char**)
 {
     testRuntimeSpan(std::span<int>        ());
     testRuntimeSpan(std::span<long>       ());
@@ -74,4 +74,6 @@ int main ()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp b/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
index 9b0034b9b..b987edb30 100644
--- a/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
+++ b/test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
@@ -28,7 +28,7 @@ const int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
 
 struct A {};
 
-int main ()
+int main(int, char**)
 {
     std::as_writeable_bytes(std::span<const int>());            // expected-error {{no matching function for call to 'as_writeable_bytes'}}
     std::as_writeable_bytes(std::span<const long>());           // expected-error {{no matching function for call to 'as_writeable_bytes'}}
@@ -44,4 +44,6 @@ int main ()
 
     std::as_writeable_bytes(std::span<const int>   (iArr2, 1));     // expected-error {{no matching function for call to 'as_writeable_bytes'}}
     std::as_writeable_bytes(std::span<const int, 1>(iArr2 + 5, 1)); // expected-error {{no matching function for call to 'as_writeable_bytes'}}
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp b/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
index 6538a5946..96bb40ec4 100644
--- a/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
+++ b/test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
@@ -45,7 +45,7 @@ void testRuntimeSpan(Span sp)
 struct A{};
 int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
 
-int main ()
+int main(int, char**)
 {
     testRuntimeSpan(std::span<int>        ());
     testRuntimeSpan(std::span<long>       ());
@@ -74,4 +74,6 @@ int main ()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.obs/empty.pass.cpp b/test/std/containers/views/span.obs/empty.pass.cpp
index e0cdb141b..9db8c8ab7 100644
--- a/test/std/containers/views/span.obs/empty.pass.cpp
+++ b/test/std/containers/views/span.obs/empty.pass.cpp
@@ -24,7 +24,7 @@ struct A{};
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert( noexcept(std::span<int>   ().empty()), "");
     static_assert( noexcept(std::span<int, 0>().empty()), "");
@@ -69,4 +69,6 @@ int main ()
     std::string s;
     assert( ((std::span<std::string>(&s, (std::ptrdiff_t) 0)).empty()));
     assert(!((std::span<std::string>(&s, 1).empty())));
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.obs/size.pass.cpp b/test/std/containers/views/span.obs/size.pass.cpp
index 0dc1dd268..f1dbc1fd9 100644
--- a/test/std/containers/views/span.obs/size.pass.cpp
+++ b/test/std/containers/views/span.obs/size.pass.cpp
@@ -40,7 +40,7 @@ struct A{};
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>(), 0),            "");
     static_assert(testConstexprSpan(std::span<long>(), 0),           "");
@@ -87,4 +87,6 @@ int main ()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0), 0);
     testRuntimeSpan(std::span<std::string>(&s, 1), 1);
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.obs/size_bytes.pass.cpp b/test/std/containers/views/span.obs/size_bytes.pass.cpp
index fa26a408f..1d423527c 100644
--- a/test/std/containers/views/span.obs/size_bytes.pass.cpp
+++ b/test/std/containers/views/span.obs/size_bytes.pass.cpp
@@ -41,7 +41,7 @@ struct A{};
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>(), 0),            "");
     static_assert(testConstexprSpan(std::span<long>(), 0),           "");
@@ -88,4 +88,6 @@ int main ()
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0), 0);
     testRuntimeSpan(std::span<std::string>(&s, 1), 1);
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.sub/first.pass.cpp b/test/std/containers/views/span.sub/first.pass.cpp
index 7d6688428..f9da9fdc2 100644
--- a/test/std/containers/views/span.sub/first.pass.cpp
+++ b/test/std/containers/views/span.sub/first.pass.cpp
@@ -68,7 +68,7 @@ constexpr int carr1[] = {1,2,3,4};
           int   arr[] = {5,6,7};
 std::string   sarr [] = { "ABC", "DEF", "GHI", "JKL", "MNO"};
 
-int main ()
+int main(int, char**)
 {
     {
     using Sp = std::span<const int>;
@@ -132,4 +132,6 @@ int main ()
     testRuntimeSpan<Sp, 4>(Sp{sarr});
     testRuntimeSpan<Sp, 5>(Sp{sarr});
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.sub/last.pass.cpp b/test/std/containers/views/span.sub/last.pass.cpp
index 171556047..e0a399ff9 100644
--- a/test/std/containers/views/span.sub/last.pass.cpp
+++ b/test/std/containers/views/span.sub/last.pass.cpp
@@ -68,7 +68,7 @@ constexpr int carr1[] = {1,2,3,4};
           int   arr[] = {5,6,7};
 std::string   sarr [] = { "ABC", "DEF", "GHI", "JKL", "MNO"};
 
-int main ()
+int main(int, char**)
 {
     {
     using Sp = std::span<const int>;
@@ -132,4 +132,6 @@ int main ()
     testRuntimeSpan<Sp, 4>(Sp{sarr});
     testRuntimeSpan<Sp, 5>(Sp{sarr});
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/span.sub/subspan.pass.cpp b/test/std/containers/views/span.sub/subspan.pass.cpp
index 22446adbb..9cb731093 100644
--- a/test/std/containers/views/span.sub/subspan.pass.cpp
+++ b/test/std/containers/views/span.sub/subspan.pass.cpp
@@ -106,7 +106,7 @@ void testRuntimeSpan(Span sp)
 constexpr int carr1[] = {1,2,3,4};
           int  arr1[] = {5,6,7};
 
-int main ()
+int main(int, char**)
 {
     {
     using Sp = std::span<const int>;
@@ -206,4 +206,6 @@ int main ()
     testRuntimeSpan<Sp, 2>(Sp{arr1});
     testRuntimeSpan<Sp, 3>(Sp{arr1});
     }
+
+  return 0;
 }
diff --git a/test/std/containers/views/types.pass.cpp b/test/std/containers/views/types.pass.cpp
index e8ddbed16..ac6f47fa8 100644
--- a/test/std/containers/views/types.pass.cpp
+++ b/test/std/containers/views/types.pass.cpp
@@ -96,11 +96,13 @@ void test()
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     test<int>();
     test<long>();
     test<double>();
     test<std::string>();
     test<A>();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
index 1b2d9043f..2fa102e27 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
@@ -37,7 +37,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
index a8899e103..31eb1f67d 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
@@ -39,7 +39,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
index 9e7505acd..2a7fe6640 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
@@ -33,7 +33,9 @@ test()
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
index eccfad4cb..3d574de34 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
@@ -35,7 +35,9 @@ test()
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
index c3abdf010..23f6a1999 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
@@ -40,7 +40,9 @@ test()
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
index 5704f8db0..dc363c1e9 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
@@ -42,7 +42,9 @@ test()
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
index 9efb9cdb6..3684da493 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
@@ -31,7 +31,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
index 6c9c476cd..0e674f21a 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
@@ -33,7 +33,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
index 7e75911ff..e91abaf5a 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
@@ -33,7 +33,9 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
index 400126e4a..7423c3b73 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
@@ -35,7 +35,9 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
index 0b5b9c5da..0486e02fb 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
@@ -35,7 +35,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
index 2e08decfa..7dd37f760 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
@@ -34,7 +34,9 @@ test()
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
index 554ce3165..809f6b37e 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
@@ -31,7 +31,9 @@ test()
     std::auto_ptr<A> ap2(source());
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
index bcb7d61c9..a75f13492 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
@@ -32,7 +32,9 @@ test()
     delete p1;
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
index c10beec79..7878f50f7 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
@@ -32,7 +32,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
index 271b4ffb4..1e41c8a9d 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
@@ -32,7 +32,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
index 2cd0faf27..61b6bbcc6 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
@@ -33,7 +33,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
index c74cabf79..d2ebd5668 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
@@ -49,7 +49,9 @@ test()
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp b/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
index 36e59dd0f..a4dac7615 100644
--- a/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
@@ -30,9 +30,11 @@ test()
     ((void)p);
 }
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<double>();
     test<void>();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp b/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/assert_h.pass.cpp b/test/std/depr/depr.c.headers/assert_h.pass.cpp
index aee59570a..d680f33ef 100644
--- a/test/std/depr/depr.c.headers/assert_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/assert_h.pass.cpp
@@ -14,6 +14,8 @@
 #error assert not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/ciso646.pass.cpp b/test/std/depr/depr.c.headers/ciso646.pass.cpp
index 2f962bc8b..3eb4064e6 100644
--- a/test/std/depr/depr.c.headers/ciso646.pass.cpp
+++ b/test/std/depr/depr.c.headers/ciso646.pass.cpp
@@ -10,6 +10,8 @@
 
 #include <ciso646>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/complex.h.pass.cpp b/test/std/depr/depr.c.headers/complex.h.pass.cpp
index 6502bb669..d92ddb67b 100644
--- a/test/std/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/std/depr/depr.c.headers/complex.h.pass.cpp
@@ -10,8 +10,10 @@
 
 #include <complex.h>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/ctype_h.pass.cpp b/test/std/depr/depr.c.headers/ctype_h.pass.cpp
index 7c7c83a83..61b539d40 100644
--- a/test/std/depr/depr.c.headers/ctype_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/ctype_h.pass.cpp
@@ -68,7 +68,7 @@
 #error toupper defined
 #endif
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<decltype(isalnum(0)), int>::value), "");
     static_assert((std::is_same<decltype(isalpha(0)), int>::value), "");
@@ -99,4 +99,6 @@ int main()
     assert(isxdigit('a'));
     assert(tolower('A') == 'a');
     assert(toupper('a') == 'A');
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/errno_h.pass.cpp b/test/std/depr/depr.c.headers/errno_h.pass.cpp
index 51ad3fe7c..985cdc7f5 100644
--- a/test/std/depr/depr.c.headers/errno_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/errno_h.pass.cpp
@@ -27,6 +27,8 @@
 #error errno not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/fenv_h.pass.cpp b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
index b6c2549b5..3a6f63c3f 100644
--- a/test/std/depr/depr.c.headers/fenv_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
@@ -57,7 +57,7 @@
 #error FE_DFL_ENV not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     fenv_t fenv = {};
     fexcept_t fex = 0;
@@ -72,4 +72,6 @@ int main()
     static_assert((std::is_same<decltype(feholdexcept(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(fesetenv(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(feupdateenv(&fenv)), int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/float_h.pass.cpp b/test/std/depr/depr.c.headers/float_h.pass.cpp
index 3e73b385d..779fbc66f 100644
--- a/test/std/depr/depr.c.headers/float_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/float_h.pass.cpp
@@ -178,6 +178,8 @@
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/inttypes_h.pass.cpp b/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
index 6db3a42f1..a08873311 100644
--- a/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/inttypes_h.pass.cpp
@@ -877,7 +877,7 @@ template <class T> void test()
     ((void)t); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<int8_t >();
     test<int16_t>();
@@ -927,4 +927,6 @@ int main()
     static_assert((std::is_same<decltype(strtoumax("", (char**)0, 0)), uintmax_t>::value), "");
     static_assert((std::is_same<decltype(wcstoimax(L"", (wchar_t**)0, 0)), intmax_t>::value), "");
     static_assert((std::is_same<decltype(wcstoumax(L"", (wchar_t**)0, 0)), uintmax_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/iso646_h.pass.cpp b/test/std/depr/depr.c.headers/iso646_h.pass.cpp
index dee560858..77ca12627 100644
--- a/test/std/depr/depr.c.headers/iso646_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/iso646_h.pass.cpp
@@ -10,7 +10,9 @@
 
 #include <iso646.h>
 
-int main()
+int main(int, char**)
 {
     // Nothing to test
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/limits_h.pass.cpp b/test/std/depr/depr.c.headers/limits_h.pass.cpp
index a8ad39215..5dba10edf 100644
--- a/test/std/depr/depr.c.headers/limits_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/limits_h.pass.cpp
@@ -86,6 +86,8 @@
 #error ULLONG_MAX not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/locale_h.pass.cpp b/test/std/depr/depr.c.headers/locale_h.pass.cpp
index 9774dd6e8..fd2419bb7 100644
--- a/test/std/depr/depr.c.headers/locale_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/locale_h.pass.cpp
@@ -39,9 +39,11 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     lconv lc; ((void)lc);
     static_assert((std::is_same<decltype(setlocale(0, "")), char*>::value), "");
     static_assert((std::is_same<decltype(localeconv()), lconv*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/math_h.pass.cpp b/test/std/depr/depr.c.headers/math_h.pass.cpp
index 562597106..b0b6c0cb3 100644
--- a/test/std/depr/depr.c.headers/math_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/math_h.pass.cpp
@@ -1463,7 +1463,7 @@ void test_trunc()
     assert(trunc(1) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test_abs();
     test_acos();
@@ -1535,4 +1535,6 @@ int main()
     test_scalbn();
     test_tgamma();
     test_trunc();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/setjmp_h.pass.cpp b/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
index 3c8584b1b..1878f4f84 100644
--- a/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/setjmp_h.pass.cpp
@@ -15,10 +15,12 @@
 #error setjmp not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     jmp_buf jb;
     ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(longjmp(jb, 0)), void>::value");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/signal_h.pass.cpp b/test/std/depr/depr.c.headers/signal_h.pass.cpp
index e2fc456e4..463d670ba 100644
--- a/test/std/depr/depr.c.headers/signal_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/signal_h.pass.cpp
@@ -47,10 +47,12 @@
 #error SIGTERM not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     sig_atomic_t sig; ((void)sig);
     typedef void (*func)(int);
     static_assert((std::is_same<decltype(signal(0, (func)0)), func>::value), "");
     static_assert((std::is_same<decltype(raise(0)), int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/stdarg_h.pass.cpp b/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
index a336fe59f..feb9c4a46 100644
--- a/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdarg_h.pass.cpp
@@ -30,8 +30,10 @@
 #error va_start not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     va_list va;
     ((void)va);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/stdbool_h.pass.cpp b/test/std/depr/depr.c.headers/stdbool_h.pass.cpp
index 38dfc6d84..132ad9c5c 100644
--- a/test/std/depr/depr.c.headers/stdbool_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdbool_h.pass.cpp
@@ -26,6 +26,8 @@
 #error false should not be defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/stddef_h.pass.cpp b/test/std/depr/depr.c.headers/stddef_h.pass.cpp
index 8c420de52..c54c976ee 100644
--- a/test/std/depr/depr.c.headers/stddef_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stddef_h.pass.cpp
@@ -22,7 +22,7 @@
 #error offsetof not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     void *p = NULL;
     assert(!p);
@@ -65,4 +65,6 @@ int main()
                   std::alignment_of<void*>::value,
                   "std::alignment_of<max_align_t>::value >= "
                   "std::alignment_of<void*>::value");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/stdint_h.pass.cpp b/test/std/depr/depr.c.headers/stdint_h.pass.cpp
index e031e2103..68efe7992 100644
--- a/test/std/depr/depr.c.headers/stdint_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdint_h.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     // typedef int8_t
     static_assert(sizeof(int8_t)*CHAR_BIT == 8,
@@ -287,4 +287,6 @@ int main()
 #ifndef UINTMAX_C
 #error UINTMAX_C not defined
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/stdio_h.pass.cpp b/test/std/depr/depr.c.headers/stdio_h.pass.cpp
index b60279696..97ea0d415 100644
--- a/test/std/depr/depr.c.headers/stdio_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdio_h.pass.cpp
@@ -103,7 +103,7 @@
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" // for tmpnam
 #endif
 
-int main()
+int main(int, char**)
 {
     FILE* fp = 0;
     fpos_t fpos = fpos_t();
@@ -165,4 +165,6 @@ int main()
     static_assert((std::is_same<decltype(feof(fp)), int>::value), "");
     static_assert((std::is_same<decltype(ferror(fp)), int>::value), "");
     static_assert((std::is_same<decltype(perror("")), void>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/stdlib_h.pass.cpp b/test/std/depr/depr.c.headers/stdlib_h.pass.cpp
index c035cf046..4c0218d6e 100644
--- a/test/std/depr/depr.c.headers/stdlib_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/stdlib_h.pass.cpp
@@ -63,7 +63,7 @@
 #error RAND_MAX not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     size_t s = 0; ((void)s);
     div_t d; ((void)d);
@@ -116,4 +116,6 @@ int main()
     static_assert((std::is_same<decltype(wctomb(pc,L' ')), int>::value), "");
     static_assert((std::is_same<decltype(mbstowcs(pw,"",0)), size_t>::value), "");
     static_assert((std::is_same<decltype(wcstombs(pc,pwc,0)), size_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/string_h.pass.cpp b/test/std/depr/depr.c.headers/string_h.pass.cpp
index 62c552b9b..8ed1513b3 100644
--- a/test/std/depr/depr.c.headers/string_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/string_h.pass.cpp
@@ -15,7 +15,7 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     size_t s = 0;
     void* vp = 0;
@@ -57,4 +57,6 @@ int main()
     static_assert((std::is_same<decltype(strstr(cpc, cpc)), const char*>::value), "");
     static_assert((std::is_same<decltype(memchr(vpc, 0, s)), const void*>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
index e9c480605..28cf93ada 100644
--- a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -10,10 +10,12 @@
 
 #include <tgmath.h>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     (void)cd;
     double x = sin(1.0);
     (void)x; // to placate scan-build
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/time_h.pass.cpp b/test/std/depr/depr.c.headers/time_h.pass.cpp
index eb9565128..5c2cc57bc 100644
--- a/test/std/depr/depr.c.headers/time_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/time_h.pass.cpp
@@ -19,7 +19,7 @@
 #error CLOCKS_PER_SEC not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     clock_t c = 0; ((void)c);
     size_t s = 0;
@@ -36,4 +36,6 @@ int main()
     char* c1 = 0;
     const char* c2 = 0;
     static_assert((std::is_same<decltype(strftime(c1,s,c2,&tmv)), size_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/uchar_h.pass.cpp b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
index bff39d2c8..cddf7a284 100644
--- a/test/std/depr/depr.c.headers/uchar_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
@@ -15,6 +15,8 @@
 
 #include <uchar.h>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/wchar_h.pass.cpp b/test/std/depr/depr.c.headers/wchar_h.pass.cpp
index 607215995..b964ea76f 100644
--- a/test/std/depr/depr.c.headers/wchar_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/wchar_h.pass.cpp
@@ -28,7 +28,7 @@
 #error WEOF not defined
 #endif
 
-int main()
+int main(int, char**)
 {
 // mbstate_t comes from the underlying C library; it is defined (in C99) as:
 //    a complete object type other than an array type that can hold the conversion
@@ -126,4 +126,6 @@ int main()
     static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(wprintf(L"")), int>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.c.headers/wctype_h.pass.cpp b/test/std/depr/depr.c.headers/wctype_h.pass.cpp
index f4dc1bf4f..1774a7f08 100644
--- a/test/std/depr/depr.c.headers/wctype_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/wctype_h.pass.cpp
@@ -87,7 +87,7 @@
 #error wctrans defined
 #endif
 
-int main()
+int main(int, char**)
 {
     wint_t w = 0;
     wctrans_t wctr = 0;
@@ -110,4 +110,6 @@ int main()
     static_assert((std::is_same<decltype(towupper(w)), wint_t>::value), "");
     static_assert((std::is_same<decltype(towctrans(w, wctr)), wint_t>::value), "");
     static_assert((std::is_same<decltype(wctrans("")), wctrans_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
index 062bbaee8..feb345b9a 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
@@ -18,7 +18,9 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_binary_function<int, short, double> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
index 8d099e52c..53df5f348 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
@@ -17,10 +17,12 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_binary_function<int, short, double> F;
     static_assert((std::is_base_of<std::binary_function<int, short, double>, F>::value), "");
     const F f(binary_f);
     assert(f(36, 27) == 9.75);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
index cc3bb6dcf..9d2d891bb 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
@@ -18,7 +18,9 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, double> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
index e039fb4c6..776fd309b 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
@@ -17,10 +17,12 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, double> F;
     static_assert((std::is_base_of<std::unary_function<int, double>, F>::value), "");
     const F f(unary_f);
     assert(f(36) == -35.5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
index 3efe3db56..e0e7889e9 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
@@ -21,7 +21,9 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(unary_f)(36) == -35.5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
index 323a55981..b356be2e9 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
@@ -19,7 +19,9 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(unary_f)(36) == -35.5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
index d1ad26362..d97507296 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
@@ -21,7 +21,9 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
index 1bffccff5..885f7db67 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
@@ -19,7 +19,9 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
index 86cc02ec3..e346f07cc 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a3)(&a) == 1);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
index f4a73e753..d7052ee5a 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a3)(&a) == 1);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
index 4f1e0aa70..e489a558e 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a4)(&a, 6) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
index 6f89ec180..f3c35f257 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a4)(&a, 6) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
index 903e13c97..14368e6e9 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_ref_t<double, A, unsigned> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
index 6e6c60d60..50782e09a 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_ref_t<double, A, unsigned> F;
     static_assert((std::is_base_of<std::binary_function<A, unsigned, double>, F>::value), "");
     const F f(&A::a4);
     const A a = A();
     assert(f(a, 6) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
index 242c977a2..afa0b781f 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_t<double, A, unsigned> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
index f4a78729e..cf0218e8f 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_t<double, A, unsigned> F;
     static_assert((std::is_base_of<std::binary_function<const A*, unsigned, double>, F>::value), "");
     const F f(&A::a4);
     const A a = A();
     assert(f(&a, 6) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
index 93322099d..1217cfe59 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a3)(a) == 1);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
index 5f05821c8..776531990 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a3)(a) == 1);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
index 44eee11be..58251d130 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a4)(a, 6) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
index 55586a91f..4015675f8 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a4)(a, 6) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
index eac582062..577cfe537 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_ref_t<int, A> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
index 3654ec2f1..61382dc40 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_ref_t<int, A> F;
     static_assert((std::is_base_of<std::unary_function<A, int>, F>::value), "");
     const F f(&A::a3);
     const A a = A();
     assert(f(a) == 1);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
index 824cdf9ad..ee24e4116 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_t<int, A> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
index 2814dccf8..ca1065abf 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_t<int, A> F;
     static_assert((std::is_base_of<std::unary_function<const A*, int>, F>::value), "");
     const F f(&A::a3);
     const A a = A();
     assert(f(&a) == 1);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
index d54896c55..a000ac5ee 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a1)(&a) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
index e1bbb65d6..6b707c4ad 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a1)(&a) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
index c4f9dcb4e..626c9102e 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a2)(&a, 5) == 6);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
index d5261e211..5abf157a6 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a2)(&a, 5) == 6);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
index 653ea2147..4ac39e764 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_ref_t<short, A, int> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
index 416c20856..ec21c42c9 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_ref_t<short, A, int> F;
     static_assert((std::is_base_of<std::binary_function<A, int, short>, F>::value), "");
     const F f(&A::a2);
     A a;
     assert(f(a, 5) == 6);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
index 3d77237a2..6471f8e91 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_t<short, A, int> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
index 8403d471d..d696bae06 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_t<short, A, int> F;
     static_assert((std::is_base_of<std::binary_function<A*, int, short>, F>::value), "");
     const F f(&A::a2);
     A a;
     assert(f(&a, 5) == 6);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
index 4eaa53eee..e6227509f 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a1)(a) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
index 6ceff9257..e22a7f03d 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a1)(a) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
index 2a73da49e..c633e769d 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a2)(a, 5) == 6);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
index 19c4dca9e..1ff7a9af9 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
@@ -24,8 +24,10 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a2)(a, 5) == 6);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
index 0717a41b9..02c3213be 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_ref_t<char, A> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
index 0fac15b3d..037454ed2 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_ref_t<char, A> F;
     static_assert((std::is_base_of<std::unary_function<A, char>, F>::value), "");
     const F f(&A::a1);
     A a;
     assert(f(a) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
index 25c3ce85f..ec379d724 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_t<char, A> F;
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
index 36205d11b..e14ea14d1 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
@@ -23,11 +23,13 @@ struct A
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_t<char, A> F;
     static_assert((std::is_base_of<std::unary_function<A*, char>, F>::value), "");
     const F f(&A::a1);
     A a;
     assert(f(&a) == 5);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp b/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
index affa79636..dbe6d1eb9 100644
--- a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
@@ -21,9 +21,11 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::binary_function<int, unsigned, char>::first_argument_type, int>::value), "");
     static_assert((std::is_same<std::binary_function<int, unsigned, char>::second_argument_type, unsigned>::value), "");
     static_assert((std::is_same<std::binary_function<int, unsigned, char>::result_type, char>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
index c0be3d8a5..0aaf3fc13 100644
--- a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
@@ -20,8 +20,10 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::unary_function<unsigned, char>::argument_type, unsigned>::value), "");
     static_assert((std::is_same<std::unary_function<unsigned, char>::result_type, char>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp b/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.ios.members/io_state.pass.cpp b/test/std/depr/depr.ios.members/io_state.pass.cpp
index 080620599..37b23fc5e 100644
--- a/test/std/depr/depr.ios.members/io_state.pass.cpp
+++ b/test/std/depr/depr.ios.members/io_state.pass.cpp
@@ -20,10 +20,12 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     std::strstream::io_state b = std::strstream::eofbit;
     assert(b == std::ios::eofbit);
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.ios.members/open_mode.pass.cpp b/test/std/depr/depr.ios.members/open_mode.pass.cpp
index b8088f651..57a88c957 100644
--- a/test/std/depr/depr.ios.members/open_mode.pass.cpp
+++ b/test/std/depr/depr.ios.members/open_mode.pass.cpp
@@ -20,10 +20,12 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     std::strstream::open_mode b = std::strstream::app;
     assert(b == std::ios::app);
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.ios.members/seek_dir.pass.cpp b/test/std/depr/depr.ios.members/seek_dir.pass.cpp
index 6c808cb71..5b48073bd 100644
--- a/test/std/depr/depr.ios.members/seek_dir.pass.cpp
+++ b/test/std/depr/depr.ios.members/seek_dir.pass.cpp
@@ -20,10 +20,12 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     std::strstream::seek_dir b = std::strstream::cur;
     assert(b == std::ios::cur);
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.ios.members/streamoff.pass.cpp b/test/std/depr/depr.ios.members/streamoff.pass.cpp
index 66200175c..8abced55e 100644
--- a/test/std/depr/depr.ios.members/streamoff.pass.cpp
+++ b/test/std/depr/depr.ios.members/streamoff.pass.cpp
@@ -20,10 +20,12 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     static_assert((std::is_integral<std::ios_base::streamoff>::value), "");
     static_assert((std::is_signed<std::ios_base::streamoff>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.ios.members/streampos.pass.cpp b/test/std/depr/depr.ios.members/streampos.pass.cpp
index 7af7c97e2..7e9572703 100644
--- a/test/std/depr/depr.ios.members/streampos.pass.cpp
+++ b/test/std/depr/depr.ios.members/streampos.pass.cpp
@@ -20,9 +20,11 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     static_assert((std::is_same<std::ios_base::streampos, std::streampos>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
index b06816a22..e00cfe7c3 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::bind1st(test_func(1), 5); // expected-error{{'bind1st<test_func, int>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
index e9fc7b39c..5d89f369f 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
@@ -18,7 +18,9 @@
 
 #include "../test_func.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::bind1st(test_func(1), 5)(10.) == -5.);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
index eca83a007..d31189b0b 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::bind2nd(test_func(1), 5); // expected-error{{'bind2nd<test_func, int>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
index a7f19fe98..243ffd116 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
@@ -18,7 +18,9 @@
 
 #include "../test_func.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::bind2nd(test_func(1), 5)(10) == 5.);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
index 3ee4154b9..92d93b01f 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::binder1st<test_func> B1ST; // expected-error{{'binder1st<test_func>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
index 18d4df48d..66df2614e 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
@@ -51,8 +51,10 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     t.do_test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
index adecc53bd..f2dd19072 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::binder2nd<test_func> B2ND; // expected-error{{'binder2nd<test_func>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
index 3671d8244..f8cb7d467 100644
--- a/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
+++ b/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
@@ -51,8 +51,10 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     t.do_test();
+
+  return 0;
 }
diff --git a/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp b/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
+++ b/test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
index 9cce2a3d8..90288578f 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@ int main()
         assert(buf[9] == 'o');
         assert(buf[10] == 'g');
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
index 6cf4b621b..867225bf8 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@ int main()
         assert(buf[5] == '.');
         assert(buf[6] == '5');
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
index b73bf32c9..106aaa768 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@ int main()
         assert(buf[9] == 'g');
         assert(buf[10] == 'g');
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
index 914212031..79a0bfeec 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@ int main()
         assert(buf[5] == '5');
         assert(buf[6] == '5');
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
index 66de73a57..68b2ee8c4 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
@@ -23,4 +23,6 @@ int main()
         std::strstreambuf* sb = in.rdbuf();
         assert(sb->sgetc() == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
index f4b91c97a..bae107838 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
@@ -15,11 +15,13 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
         std::istrstream in(buf);
         assert(in.str() == std::string("123 4.5 dog"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
index 94c2a4885..80f5af082 100644
--- a/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
@@ -16,7 +16,9 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::istream, std::istrstream>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
index edece7db0..81c84fe32 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -38,4 +38,6 @@ int main()
         out << i << ' ' << d << ' ' << s << std::ends;
         assert(out.str() == std::string("123 4.5 dog321 5.5 cat"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
index 96417da11..5f9e9e6a8 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::ostrstream out;
     int i = 123;
@@ -25,4 +25,6 @@ int main()
     out << i << ' ' << d << ' ' << s << std::ends;
     assert(out.str() == std::string("123 4.5 dog"));
     out.freeze(false);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
index 817597168..4b3412edc 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostrstream out;
@@ -30,4 +30,6 @@ int main()
         assert(out.str() == std::string("a"));
         out.freeze(false);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
index a592848ed..73a4bb81e 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostrstream out;
@@ -23,4 +23,6 @@ int main()
         out << 123 << ' ' << 4.5 << ' ' << "dog";
         assert(out.pcount() == 11);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
index 547dde064..ff58af45b 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -24,4 +24,6 @@ int main()
         assert(sb->sputc('a') == 'a');
         assert(buf == std::string("a23 4.5 dog"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
index c9f3e8dc0..60ec02f34 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostrstream out;
@@ -23,4 +23,6 @@ int main()
         assert(out.str() == std::string("123 4.5 dog"));
         out.freeze(false);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
index b394f8326..5fde85037 100644
--- a/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
@@ -16,7 +16,9 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::ostream, std::ostrstream>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
index 0a5429646..2387b1eeb 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -56,4 +56,6 @@ int main()
         inout << i << ' ' << d << ' ' << s;
         assert(inout.str() == std::string("123 4.5 dog321 5.5 cat"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
index ff68a3d1d..0e278490a 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 #include <cstring>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::strstream inout;
     int i = 123;
@@ -33,4 +33,6 @@ int main()
     assert(d == 4.5);
     assert(std::strcmp(s.c_str(), "dog") == 0);
     inout.freeze(false);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
index f02e71324..b4eb17397 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -24,4 +24,6 @@ int main()
         assert(sb->sputc('a') == 'a');
         assert(buf == std::string("a23 4.5 dog"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
index 8fd137ea6..dab7c04a6 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstream out;
@@ -30,4 +30,6 @@ int main()
         assert(out.str() == std::string("a"));
         out.freeze(false);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
index 56624f2b2..3a7641b23 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstream out;
@@ -23,4 +23,6 @@ int main()
         out << 123 << ' ' << 4.5 << ' ' << "dog";
         assert(out.pcount() == 11);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
index e780e843f..f3482c756 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstream out;
@@ -23,4 +23,6 @@ int main()
         assert(out.str() == std::string("123 4.5 dog"));
         out.freeze(false);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
index 81979d0af..7944b7899 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
@@ -21,11 +21,13 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::iostream, std::strstream>::value), "");
     static_assert((std::is_same<std::strstream::char_type, char>::value), "");
     static_assert((std::is_same<std::strstream::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::strstream::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::strstream::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
index e9003c9e6..08cb61914 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "abcd";
@@ -36,4 +36,6 @@ int main()
         assert(sb.snextc() == 'd');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
index c5acd63a0..19eb15f94 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "abcd";
@@ -93,4 +93,6 @@ int main()
         assert(sb.snextc() == 'j');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
index d38b8d3c8..8cba11fac 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const signed char buf[] = "abcd";
@@ -36,4 +36,6 @@ int main()
         assert(sb.snextc() == 'd');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
index 03dc3056e..9546b74db 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned char buf[] = "abcd";
@@ -36,4 +36,6 @@ int main()
         assert(sb.snextc() == 'd');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
index 997e6707c..d7587c005 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
@@ -38,7 +38,7 @@ struct test
         {return std::strstreambuf::overflow(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test s(my_alloc, my_free);
@@ -47,4 +47,6 @@ int main()
         assert(called == 1);
     }
     assert(called == 2);
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
index 49da5b262..2764efd0e 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf s;
@@ -27,4 +27,6 @@ int main()
         assert(s.str() == nullptr);
         assert(s.pcount() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
index 5d419f7a4..fdd46164b 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     {
         signed char buf[] = "abcd";
@@ -93,4 +93,6 @@ int main()
         assert(sb.snextc() == 'j');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
index 6a7467dec..80aafd448 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned char buf[] = "abcd";
@@ -93,4 +93,6 @@ int main()
         assert(sb.snextc() == 'j');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
index d798eb308..4cbb7b80a 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf sb;
@@ -24,4 +24,6 @@ int main()
         sb.freeze(false);
         assert(sb.sputc('a') == 'a');
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
index 7d98f8cfd..b47a34ed8 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <strstream>
 
-int main() {
+int main(int, char**) {
   std::ostrstream oss;
   std::string s;
 
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
index 901dc4a9c..1d2f34d92 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf sb;
@@ -28,4 +28,6 @@ int main()
         assert(sb.pcount() == 2);
         sb.freeze(false);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
index 933b6306e..04ecb94cb 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf sb;
@@ -24,4 +24,6 @@ int main()
         assert(sb.str() == std::string("a"));
         sb.freeze(false);
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
index 0e5f6a7e6..19cb7abf1 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[12] = "abc";
@@ -43,4 +43,6 @@ int main()
         assert(sb.sputc('1') == '1');
         assert(sb.str() == std::string("12345678901"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
index 8364ab7ff..59fdb640d 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
@@ -27,7 +27,7 @@ struct test
     virtual int_type pbackfail(int_type c = EOF) {return base::pbackfail(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123";
@@ -58,4 +58,6 @@ int main()
         assert(sb.pbackfail(EOF) == EOF);
         assert(sb.str() == std::string("133"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
index 9b5ba9ada..8e1f22eeb 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
@@ -16,7 +16,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "0123456789";
@@ -53,4 +53,6 @@ int main()
         assert(sb.sputc('c') == 'c');
         assert(sb.str() == std::string("012a456c89"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
index f888a4d88..9d13dc4aa 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
@@ -16,7 +16,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "0123456789";
@@ -35,4 +35,6 @@ int main()
         assert(sb.sputc('a') == 'a');
         assert(sb.str() == std::string("012a456789"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
index 85c308ad5..c78004e21 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "0123456789";
@@ -23,4 +23,6 @@ int main()
         assert(sb.pubsetbuf(0, 0) == &sb);
         assert(sb.str() == std::string("0123456789"));
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
index a28d943d9..e8da2957c 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
@@ -27,7 +27,7 @@ struct test
     base::int_type underflow() {return base::underflow();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         char buf[10] = "123";
@@ -47,4 +47,6 @@ int main()
         assert(sb.underflow() == '4');
         assert(sb.underflow() == '4');
     }
+
+  return 0;
 }
diff --git a/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp b/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
index 755916f65..398605af9 100644
--- a/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
+++ b/test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
@@ -14,7 +14,9 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::streambuf, std::strstreambuf>::value), "");
+
+  return 0;
 }
diff --git a/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp b/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
+++ b/test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp b/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
index 0974b2ee9..7b11c3037 100644
--- a/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
+++ b/test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
@@ -22,7 +22,7 @@ void f3()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
 
     std::unexpected_handler old = std::get_unexpected();
@@ -37,4 +37,6 @@ int main()
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
diff --git a/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp b/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
index f46d1d4ee..38ae81ec9 100644
--- a/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
+++ b/test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
@@ -22,7 +22,7 @@ void f3()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unexpected_handler old = std::set_unexpected(f1);
     // verify there is a previous unexpected handler
@@ -33,4 +33,6 @@ int main()
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
diff --git a/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp b/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
index 549f8e0a5..e4d4869d7 100644
--- a/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
+++ b/test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
@@ -14,8 +14,10 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     std::unexpected_handler p = f;
     ((void)p);
+
+  return 0;
 }
diff --git a/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp b/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
index 883aa9237..2562b7884 100644
--- a/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
+++ b/test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
@@ -19,9 +19,11 @@ void f1()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_unexpected(f1);
     std::unexpected();
     assert(false);
+
+  return 0;
 }
diff --git a/test/std/depr/nothing_to_do.pass.cpp b/test/std/depr/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/depr/nothing_to_do.pass.cpp
+++ b/test/std/depr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/assertions/cassert.pass.cpp b/test/std/diagnostics/assertions/cassert.pass.cpp
index fe54e1852..a18a4d0df 100644
--- a/test/std/diagnostics/assertions/cassert.pass.cpp
+++ b/test/std/diagnostics/assertions/cassert.pass.cpp
@@ -14,6 +14,8 @@
 #error assert not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp b/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/errno/cerrno.pass.cpp b/test/std/diagnostics/errno/cerrno.pass.cpp
index 100e5b30b..452f99e33 100644
--- a/test/std/diagnostics/errno/cerrno.pass.cpp
+++ b/test/std/diagnostics/errno/cerrno.pass.cpp
@@ -339,6 +339,8 @@
 #error errno not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/nothing_to_do.pass.cpp b/test/std/diagnostics/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/diagnostics/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp b/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
index 14ded723f..31a320d11 100644
--- a/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::domain_error>::value),
                  "std::is_base_of<std::logic_error, std::domain_error>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp b/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
index bcdfe477b..00d9a9296 100644
--- a/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::invalid_argument>::value),
                  "std::is_base_of<std::logic_error, std::invalid_argument>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp b/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
index 754f79061..1e8f1e46c 100644
--- a/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::length_error>::value),
                  "std::is_base_of<std::logic_error, std::length_error>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp b/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
index 279ac7345..e30b3b9f8 100644
--- a/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::logic_error>::value),
                  "std::is_base_of<std::exception, std::logic_error>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp b/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
index 8f5a8f2f8..01a5b46b4 100644
--- a/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::out_of_range>::value),
                  "std::is_base_of<std::logic_error, std::out_of_range>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp b/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
index 0e576290d..a9e7fb994 100644
--- a/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::runtime_error, std::overflow_error>::value),
                  "std::is_base_of<std::runtime_error, std::overflow_error>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp b/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
index 211c53d12..92d1151ff 100644
--- a/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::runtime_error, std::range_error>::value),
                  "std::is_base_of<std::runtime_error, std::range_error>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp b/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
index dae3371cd..c4b8eea74 100644
--- a/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::runtime_error>::value),
                  "std::is_base_of<std::exception, std::runtime_error>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp b/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
index f2588576a..88a3f46fb 100644
--- a/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
+++ b/test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::runtime_error, std::underflow_error>::value),
                  "std::is_base_of<std::runtime_error, std::underflow_error>::value");
@@ -38,4 +38,6 @@ int main()
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/errc.pass.cpp b/test/std/diagnostics/syserr/errc.pass.cpp
index 0738264af..201878d2d 100644
--- a/test/std/diagnostics/syserr/errc.pass.cpp
+++ b/test/std/diagnostics/syserr/errc.pass.cpp
@@ -12,7 +12,7 @@
 
 #include <system_error>
 
-int main()
+int main(int, char**)
 {
     static_assert(static_cast<int>(std::errc::address_family_not_supported) == EAFNOSUPPORT, "");
     static_assert(static_cast<int>(std::errc::address_in_use) == EADDRINUSE, "");
@@ -100,4 +100,6 @@ int main()
     static_assert(static_cast<int>(std::errc::too_many_symbolic_link_levels) == ELOOP, "");
     static_assert(static_cast<int>(std::errc::value_too_large) == EOVERFLOW, "");
     static_assert(static_cast<int>(std::errc::wrong_protocol_type) == EPROTOTYPE, "");
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
index 2b1416e15..2a44b5ee3 100644
--- a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
@@ -39,7 +39,7 @@ namespace std
 }
 
 
-int main()
+int main(int, char**)
 {
     test<false, void>();
     test<false, int>();
@@ -47,4 +47,6 @@ int main()
     test<false, std::string>();
 
     test<true, A>();
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
index 8398c70fe..df89fc334 100644
--- a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
@@ -39,7 +39,7 @@ namespace std
 }
 
 
-int main()
+int main(int, char**)
 {
     test<false, void>();
     test<false, int>();
@@ -47,4 +47,6 @@ int main()
     test<false, std::string>();
 
     test<true, A>();
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
index 425406ade..0e2dbe552 100644
--- a/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
@@ -20,7 +20,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::error_code e_code1(5, std::generic_category());
     std::error_code e_code2(5, std::system_category());
@@ -102,4 +102,6 @@ int main()
     assert(e_condition4 != e_condition2);
     assert(e_condition4 != e_condition3);
     assert(e_condition4 == e_condition4);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
index 8aa7fedf6..ed580198e 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
@@ -18,7 +18,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::system_category();
@@ -30,4 +30,6 @@ int main()
     assert(!m3.empty());
     assert(m1 == m2);
     assert(m1 != m3);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
index 8e5bda762..185f96e26 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
@@ -27,8 +27,10 @@ public:
     virtual std::string message(int) const {return std::string();}
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_nothrow_default_constructible<test1>::value,
                                  "error_category() must exist and be noexcept");
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
index abe0c3687..ce09481e3 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::generic_category();
     const std::error_category& e_cat3 = std::system_category();
     assert(e_cat1 == e_cat2);
     assert(!(e_cat1 == e_cat3));
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
index 9b9a1acc0..db6b3b908 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::generic_category();
     const std::error_category& e_cat3 = std::system_category();
     assert(!(e_cat1 < e_cat2) && !(e_cat2 < e_cat1));
     assert((e_cat1 < e_cat3) || (e_cat3 < e_cat1));
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
index 615c9a0be..2826018d3 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::generic_category();
     const std::error_category& e_cat3 = std::system_category();
     assert(!(e_cat1 != e_cat2));
     assert(e_cat1 != e_cat3);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
index 73967e90f..f04427381 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
@@ -35,7 +35,7 @@ void test_message_for_bad_value() {
     assert(errno == E2BIG);
 }
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     std::string m1 = e_cat1.name();
@@ -43,4 +43,6 @@ int main()
     {
         test_message_for_bad_value();
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
index 78d3a3ef0..8374c8766 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
@@ -35,7 +35,7 @@ void test_message_for_bad_value() {
     assert(errno == E2BIG);
 }
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::system_category();
     std::error_condition e_cond = e_cat1.default_error_condition(5);
@@ -47,4 +47,6 @@ int main()
     {
         test_message_for_bad_value();
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
index b75b6b924..112c39448 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
@@ -12,8 +12,10 @@
 
 #include <system_error>
 
-int main()
+int main(int, char**)
 {
     std::error_category* p = 0;
     ((void)p);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
index 870822cbc..07daf6f49 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
@@ -15,10 +15,12 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::generic_category();
     std::error_condition e_cond = e_cat.default_error_condition(static_cast<int>(std::errc::not_a_directory));
     assert(e_cond.category() == e_cat);
     assert(e_cond.value() == static_cast<int>(std::errc::not_a_directory));
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
index 89eb8b475..768222798 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
@@ -15,9 +15,11 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::generic_category();
     assert(e_cat.equivalent(std::error_code(5, e_cat), 5));
     assert(!e_cat.equivalent(std::error_code(5, e_cat), 6));
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
index 76cc19838..7e627d409 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
@@ -15,10 +15,12 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::generic_category();
     std::error_condition e_cond = e_cat.default_error_condition(5);
     assert(e_cat.equivalent(5, e_cond));
     assert(!e_cat.equivalent(6, e_cond));
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
index 50f48e170..bfebd012b 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
@@ -33,11 +33,13 @@ make_error_code(testing x)
     return std::error_code(static_cast<int>(x), std::generic_category());
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec(two);
         assert(ec.value() == 2);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
index 9d7fbba1d..3a7249ede 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
@@ -15,9 +15,11 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::error_code ec;
     assert(ec.value() == 0);
     assert(ec.category() == std::system_category());
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
index 99d8f9407..5a2150fbf 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec(6, std::system_category());
@@ -27,4 +27,6 @@ int main()
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
index aa99f4b3a..a98e22944 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
@@ -33,7 +33,7 @@ make_error_code(testing x)
     return std::error_code(static_cast<int>(x), std::generic_category());
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec;
@@ -41,4 +41,6 @@ int main()
         assert(ec.value() == 2);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
index 2c06d4b93..998cfd354 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec;
@@ -29,4 +29,6 @@ int main()
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
index 523562c8e..c4b7eca25 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec;
@@ -26,4 +26,6 @@ int main()
         assert(ec.value() == 0);
         assert(ec.category() == std::system_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
index 98f46eea6..9dc37fc34 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
@@ -16,11 +16,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_code ec1(6, std::generic_category());
         const std::error_code ec2(7, std::generic_category());
         assert(ec1 < ec2);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
index 7917de06e..1f4603f7c 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = make_error_code(std::errc::operation_canceled);
         assert(ec.value() == static_cast<int>(std::errc::operation_canceled));
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
index 0828c1fb8..37e1d817d 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
@@ -18,9 +18,11 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream out;
     out << std::error_code(std::io_errc::stream);
     assert(out.str() == "iostream:1");
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
index 6b9838ca7..902e108a1 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
@@ -22,7 +22,7 @@ bool test_func(void)
     return ec;   // conversion to bool is explicit; should fail.
 }
 
-int main()
+int main(int, char**)
 {
     return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
index da226788c..11bea5a34 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_code ec(6, std::generic_category());
@@ -26,4 +26,6 @@ int main()
         const std::error_code ec(0, std::generic_category());
         assert(!static_cast<bool>(ec));
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
index a2a9ef717..16197d934 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_code ec(6, std::generic_category());
     assert(ec.category() == std::generic_category());
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
index e7119a3e6..4c92b488e 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_code ec(6, std::generic_category());
@@ -27,4 +27,6 @@ int main()
         std::error_condition e_cond = ec.default_error_condition();
         assert(e_cond == ec);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
index 7482914e6..513eeae77 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
@@ -16,8 +16,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_code ec(6, std::generic_category());
     assert(ec.message() == std::generic_category().message(6));
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
index 5e15e0630..f1fcee414 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_code ec(6, std::system_category());
     assert(ec.value() == 6);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
index c5f8650d2..b2441ac97 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
@@ -14,10 +14,12 @@
 #include <system_error>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::error_code x;
     TEST_IGNORE_NODISCARD  x.category();   // returns a std::error_category &
     TEST_IGNORE_NODISCARD  x.default_error_condition(); // std::error_condition
     TEST_IGNORE_NODISCARD  x.message();    // returns a std::string
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
index 34c3af883..63e718dda 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec(std::errc::not_a_directory);
         assert(ec.value() == static_cast<int>(std::errc::not_a_directory));
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
index e30392010..f39904a12 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
@@ -15,9 +15,11 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::error_condition ec;
     assert(ec.value() == 0);
     assert(ec.category() == std::generic_category());
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
index 82b0de8b6..b30c23f19 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec(6, std::system_category());
@@ -27,4 +27,6 @@ int main()
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
index 0cefa6e32..129e30e3f 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec;
@@ -23,4 +23,6 @@ int main()
         assert(ec.value() == static_cast<int>(std::errc::not_enough_memory));
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
index 44ff3f67e..a0e27ee5e 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec;
@@ -29,4 +29,6 @@ int main()
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
index 9dd5bf303..5de51aa95 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec;
@@ -26,4 +26,6 @@ int main()
         assert(ec.value() == 0);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
index ce5768751..f1c24514b 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
@@ -16,11 +16,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1(6, std::generic_category());
         const std::error_condition ec2(7, std::generic_category());
         assert(ec1 < ec2);
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
index 6f64e49bf..e9e65db59 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1 = std::make_error_condition(std::errc::message_size);
         assert(ec1.value() == static_cast<int>(std::errc::message_size));
         assert(ec1.category() == std::generic_category());
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
index 8684393df..bccdf5fb0 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec(6, std::generic_category());
@@ -26,4 +26,6 @@ int main()
         const std::error_condition ec(0, std::generic_category());
         assert(!static_cast<bool>(ec));
     }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
index d5bbc94b3..f4710a722 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_condition ec(6, std::generic_category());
     assert(ec.category() == std::generic_category());
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
index c5fc8c60a..e533e84ee 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
@@ -16,8 +16,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_condition ec(6, std::generic_category());
     assert(ec.message() == std::generic_category().message(6));
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
index 03038e1c8..d78b17874 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_condition ec(6, std::system_category());
     assert(ec.value() == 6);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
index f6376d523..85a0155d7 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
@@ -14,9 +14,11 @@
 #include <system_error>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::error_condition x = std::errc(0);
     TEST_IGNORE_NODISCARD  x.category();   // returns a std::error_condition &
     TEST_IGNORE_NODISCARD  x.message();    // returns a std::string
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp b/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
index 6be7b4e9c..c127e900a 100644
--- a/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::error_code>();
     test_hash_enabled_for_type<std::error_condition>();
   }
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
index 0158f3ff3..f8c09775f 100644
--- a/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
@@ -36,9 +36,11 @@ test(int i)
     ((void)result); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(2);
     test(10);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp b/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
index d651e6d5c..b9b0057b9 100644
--- a/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
@@ -36,9 +36,11 @@ test(int i)
     ((void)result); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(2);
     test(10);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
index 4d59735fe..3e721c2d2 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
@@ -18,11 +18,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
                          std::generic_category(), "some text");
     assert(se.code() == std::make_error_code(std::errc::not_a_directory));
     std::string what_message(se.what());
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
index c2b229a9d..d15ff75bf 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(make_error_code(std::errc::not_a_directory), what_arg.c_str());
@@ -26,4 +26,6 @@ int main()
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
index adca00d1e..8e2b07800 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(make_error_code(std::errc::not_a_directory), what_arg);
@@ -26,4 +26,6 @@ int main()
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
index d77d20cfe..b1ac08e66 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
@@ -18,11 +18,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
                          std::generic_category());
     assert(se.code() == std::make_error_code(std::errc::not_a_directory));
     std::string what_message(se.what());
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
index 789fed6b6..a6d243267 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
@@ -27,4 +27,6 @@ int main()
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
index 29df242f0..913c675b9 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
@@ -27,4 +27,6 @@ int main()
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
diff --git a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/experimental/algorithms/alg.search/search.pass.cpp b/test/std/experimental/algorithms/alg.search/search.pass.cpp
index 4faa6549e..45b1f0972 100644
--- a/test/std/experimental/algorithms/alg.search/search.pass.cpp
+++ b/test/std/experimental/algorithms/alg.search/search.pass.cpp
@@ -35,11 +35,13 @@ struct MySearcher {
 };
 
 
-int main() {
+int main(int, char**) {
     typedef int * RI;
     static_assert((std::is_same<RI, decltype(std::experimental::search(RI(), RI(), MySearcher()))>::value), "" );
 
     RI it(nullptr);
     assert(it == std::experimental::search(it, it, MySearcher()));
     assert(searcher_called == 1);
+
+  return 0;
 }
diff --git a/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp b/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
index 6c216bd20..595162d30 100644
--- a/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
+++ b/test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
@@ -25,4 +25,6 @@
 #endif
 #endif
 
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
diff --git a/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp b/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
index 5e1920f89..87086d429 100644
--- a/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
+++ b/test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
@@ -15,9 +15,11 @@
 #include <experimental/filesystem>
 #include <type_traits>
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_same<
           std::experimental::filesystem::path,
           std::experimental::filesystem::v1::path
       >::value, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
index 21780ab80..35c5e50bb 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
@@ -121,7 +121,9 @@ test2()
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
index c1546706e..245b3ddfc 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
@@ -117,7 +117,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
index 0614cb987..ad9095475 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
@@ -135,7 +135,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
index 12ab20cdd..a361b90b8 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
@@ -126,7 +126,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
index 0cd6174af..95426f81c 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
@@ -121,7 +121,9 @@ test2()
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
index 0fe8420a5..151a0f46b 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
@@ -116,7 +116,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
index 916660c1e..bcdaa87c4 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
@@ -129,7 +129,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
index 3cdac5ffd..06a93c5d7 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
@@ -123,7 +123,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
index 524bba17d..b3f6c6638 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
@@ -82,7 +82,7 @@ test()
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -92,4 +92,6 @@ int main() {
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
index a4d0b0730..f1573a2e0 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
@@ -89,7 +89,7 @@ test()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -99,4 +99,6 @@ int main() {
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
index 3bf33c808..5187569ec 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
@@ -67,7 +67,7 @@ test()
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -77,4 +77,6 @@ int main() {
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
index a827f3d2a..a6996437e 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
@@ -74,7 +74,7 @@ test()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -84,4 +84,6 @@ int main() {
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
diff --git a/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp b/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
+++ b/test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/experimental/func/header.functional.synop/includes.pass.cpp b/test/std/experimental/func/header.functional.synop/includes.pass.cpp
index 805d8c8fd..4b913c2d7 100644
--- a/test/std/experimental/func/header.functional.synop/includes.pass.cpp
+++ b/test/std/experimental/func/header.functional.synop/includes.pass.cpp
@@ -14,7 +14,9 @@
 
 #include <experimental/functional>
 
-int main()
+int main(int, char**)
 {
   std::function<int(int)> x;
+
+  return 0;
 }
diff --git a/test/std/experimental/func/nothing_to_do.pass.cpp b/test/std/experimental/func/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/experimental/func/nothing_to_do.pass.cpp
+++ b/test/std/experimental/func/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/experimental/iterator/nothing_to_do.pass.cpp b/test/std/experimental/iterator/nothing_to_do.pass.cpp
index 85149549f..782c1a03e 100644
--- a/test/std/experimental/iterator/nothing_to_do.pass.cpp
+++ b/test/std/experimental/iterator/nothing_to_do.pass.cpp
@@ -8,4 +8,6 @@
 
 #include <experimental/iterator>
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
index 869af67bc..4e3994f95 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
@@ -24,7 +24,7 @@
 
 namespace exp = std::experimental;
 
-int main () {
+int main(int, char**) {
     const char eight = '8';
     const std::string nine = "9";
     const std::wstring ten = L"10";
@@ -54,4 +54,6 @@ int main () {
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, ten); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, eleven); }
 
-    }
+    
+  return 0;
+}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
index b8e98b904..a2dab9afb 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
@@ -39,7 +39,7 @@ void test (Delim &&d, Iter first, Iter last, const CharT *expected ) {
     assert(sstream.str() == expected);
     }
 
-int main () {
+int main(int, char**) {
     const char chars[] = "0123456789";
     const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
 
@@ -49,4 +49,6 @@ int main () {
     test('x', ints,  ints+10,  "10x11x12x13x14x15x16x17x18x19");
     test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
     test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
-    }
+    
+  return 0;
+}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
index 674f2863d..c1bf74afc 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
@@ -67,7 +67,7 @@ void test (Delim &&d, Iter first, Iter last, const CharT *expected ) {
     assert(sstream.str() == expected);
     }
 
-int main () {
+int main(int, char**) {
 {
     const char chars[] = "0123456789";
     const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
@@ -116,4 +116,6 @@ int main () {
     test(mutating_delimiter(), chars, chars+10, L"0 1!2\"3#4$5%6&7'8(9");
     }
 
+
+  return 0;
 }
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
index 69d2258b1..095020eb6 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
@@ -31,7 +31,7 @@ void test ( exp::ostream_joiner<Delim, CharT, Traits> &oj ) {
     assert( &ret == &oj );
     }
 
-int main () {
+int main(int, char**) {
 
     { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
     { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
@@ -42,4 +42,6 @@ int main () {
     { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
-    }
+    
+  return 0;
+}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
index e7210ac72..2e305c2ff 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
@@ -31,7 +31,7 @@ void test ( exp::ostream_joiner<Delim, CharT, Traits> &oj ) {
     assert( &ret == &oj );
     }
 
-int main () {
+int main(int, char**) {
 
     { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
     { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
@@ -42,4 +42,6 @@ int main () {
     { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
-    }
+    
+  return 0;
+}
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
index d9661510b..74bf9c309 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
@@ -31,7 +31,7 @@ void test ( exp::ostream_joiner<Delim, CharT, Traits> &oj ) {
     assert( &ret == &oj );
     }
 
-int main () {
+int main(int, char**) {
 
     { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
     { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
@@ -42,4 +42,6 @@ int main () {
     { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
-    }
+    
+  return 0;
+}
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
index 997864881..b3fbd2763 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
@@ -50,8 +50,10 @@ void do_test() {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
index 8b205ab89..f6290fdfa 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
@@ -44,7 +44,7 @@ void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   }
 }
 
-int main()
+int main(int, char**)
 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
@@ -56,4 +56,6 @@ int main()
     do_test<coro::coroutine_handle<>>(TC.first, TC.second);
     do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
   }
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
index 428b2e4b0..8152b53f9 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
@@ -53,7 +53,7 @@ void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   }
 }
 
-int main()
+int main(int, char**)
 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
@@ -65,4 +65,6 @@ int main()
     do_test<coro::coroutine_handle<>>(TC.first, TC.second);
     do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
   }
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
index 39c279fe8..14ac3976e 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
@@ -36,8 +36,10 @@ void do_test(coro::coroutine_handle<Promise> const& H) {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<>{});
   do_test(coro::coroutine_handle<int>{});
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
index da14b4b60..2af0b717e 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
@@ -46,8 +46,10 @@ void do_test() {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
index 84fa9314d..7832856c1 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
@@ -45,8 +45,10 @@ void do_test() {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
index 6559ad52d..3c63dbbeb 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
@@ -43,8 +43,10 @@ void do_test() {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
index 9e9490a3e..e9dd0678f 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
@@ -26,7 +26,7 @@
 
 namespace coro = std::experimental;
 
-int main()
+int main(int, char**)
 {
   {
     using H = coro::coroutine_handle<>;
@@ -42,4 +42,6 @@ int main()
     // expected-error@experimental/coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
   }
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
index e856ca12e..9c4a647e5 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
@@ -38,8 +38,10 @@ void do_test() {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
index 59c20b849..612380b6d 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
@@ -47,7 +47,7 @@ void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   }
 }
 
-int main()
+int main(int, char**)
 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
@@ -59,4 +59,6 @@ int main()
     do_test<coro::coroutine_handle<>>(TC.first, TC.second);
     do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
   }
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
index eabf03ef0..27b83ce02 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
@@ -44,7 +44,7 @@ static_assert(std::is_same<decltype(coro::noop_coroutine()), coro::noop_coroutin
 // // 18.11.2.10 noop address
 // constexpr void* address() const noexcept;
 
-int main()
+int main(int, char**)
 {
   auto h = coro::noop_coroutine();
   coro::coroutine_handle<> base = h;
@@ -65,10 +65,12 @@ int main()
   assert(h.address() == base.address());
   assert(h.address() != nullptr);
   assert(coro::coroutine_handle<>::from_address(h.address()) == base);
+
+  return 0;
 }
 
 #else
 
-int main() {}
+int main(int, char**) { return 0; }
 
 #endif //  __has_builtin(__builtin_coro_noop)
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
index 87e182e03..0f81fdca8 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
@@ -75,9 +75,11 @@ void do_test(coro::coroutine_handle<Promise>&& H) {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<int>{});
   do_test(coro::coroutine_handle<const int>{});
   do_runtime_test();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
index 693e0518f..72ba9fee6 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
@@ -53,8 +53,10 @@ void do_test(coro::coroutine_handle<Promise>&& H) {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<>{});
   do_test(coro::coroutine_handle<int>{});
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
index 85d84a435..a3804ae43 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
@@ -72,8 +72,10 @@ void do_test(coro::coroutine_handle<Promise>&& H) {
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<>{});
   do_test(coro::coroutine_handle<int>{});
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
index a2214ba10..8536e23d4 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
@@ -41,10 +41,12 @@ void check_type() {
   static_assert(std::is_same<P, Expect>::value, "");
 };
 
-int main()
+int main(int, char**)
 {
   check_type<A*, A>();
   check_type<int*, A, int>();
   check_type<B*, B>();
   check_type<void, C>();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
index b06dac41b..781f264ff 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
@@ -60,7 +60,7 @@ void check_no_type() {
   static_assert(!has_promise_type<Traits>(), "");
 }
 
-int main()
+int main(int, char**)
 {
   {
     check_type<A*, A>();
@@ -73,4 +73,6 @@ int main()
     check_no_type<E>();
     check_no_type<C, int>();
   }
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
index 93ac47196..89f1619df 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
@@ -31,7 +31,7 @@ constexpr bool check_suspend_constexpr() {
   return true;
 }
 
-int main()
+int main(int, char**)
 {
   using H = coro::coroutine_handle<>;
   using S = SuspendT;
@@ -69,4 +69,6 @@ int main()
     // suppress unused warnings for the global constexpr test variable
     ((void)constexpr_sa);
   }
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
index 2ff459417..7986b2926 100644
--- a/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool check_suspend_constexpr() {
 }
 
 
-int main()
+int main(int, char**)
 {
   using H = coro::coroutine_handle<>;
   using S = SuspendT;
@@ -71,4 +71,6 @@ int main()
     // suppress unused warnings for the global constexpr test variable
     ((void)constexpr_sn);
   }
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
index a5ec20756..c540ca9fb 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
@@ -59,10 +59,12 @@ coro_t f(int n) {
 
 coro_t g() { B val = co_await B{}; }
 
-int main() {
+int main(int, char**) {
   last_value = -1;
   f(0);
   assert(last_value == 0);
   f(1);
   assert(last_value == 42);
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
index ea30b8977..fb15ade8b 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
@@ -57,7 +57,7 @@ coro_t g() {
   g_resumed = true;
 }
 
-int main() {
+int main(int, char**) {
   assert(!f_started && !f_resumed && !g_started && !g_resumed);
   auto fret = f();
   assert(f_started && !f_resumed);
@@ -65,4 +65,6 @@ int main() {
   assert(f_started && !f_resumed);
   g();
   assert(g_started && g_resumed);
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
index 4358f6700..a899092d0 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
@@ -75,7 +75,7 @@ expected<int> f2() {
   co_return 200;
 }
 
-int main() {
+int main(int, char**) {
   auto c1 = f1();
   assert(f1_started && f1_resumed);
   assert(c1.value() == 100);
@@ -85,4 +85,6 @@ int main() {
   assert(f2_started && !f2_resumed);
   assert(c2.value() == 0);
   assert(c2.error() == 42);
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
index 62fe61a31..87d3c8f9d 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
@@ -108,9 +108,11 @@ coro2 d() {
   assert(dtor_called == 1);
 }
 
-int main() {
+int main(int, char**) {
   a();
   b();
   c();
   d();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
index e885358d2..84b4deb9c 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
@@ -95,8 +95,10 @@ void test_mini_generator() {
   assert(sum == 10);
 }
 
-int main() {
+int main(int, char**) {
   test_count();
   test_range();
   test_mini_generator();
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
index 18e96b680..994bd87d6 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
@@ -164,7 +164,7 @@ goroutine pusher(channel& left, channel& right)
 const int N = 100;
 channel* c = new channel[N + 1];
 
-int main() {
+int main(int, char**) {
   for (int i = 0; i < N; ++i)
     goroutine::go(pusher(c[i], c[i + 1]));
 
@@ -172,4 +172,6 @@ int main() {
   int result = c[N].sync_pull();
 
   assert(result == 100);
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
index 1b7bdd161..fed97ea23 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
@@ -80,7 +80,9 @@ int Do(int acc, int n, func<int> f) {
   return acc;
 }
 
-int main() {
+int main(int, char**) {
   int result = Do(1, 10, [](int a, int b) {return a + b;});
   assert(result == 46);
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
index 567f438da..4bab2dd3b 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
@@ -72,11 +72,13 @@ float fyield(int x) { yielded_values.push_back(x); return static_cast<float>(x +
 void Do1(func<int> f) { yield(f()); }
 void Do2(func<double> f) { yield(static_cast<int>(f())); }
 
-int main() {
+int main(int, char**) {
   Do1([] { return yield(43); });
   assert((yielded_values == std::vector<int>{43, 44}));
 
   yielded_values = {};
   Do2([] { return fyield(44); });
   assert((yielded_values == std::vector<int>{44, 46}));
+
+  return 0;
 }
diff --git a/test/std/experimental/language.support/support.coroutines/includes.pass.cpp b/test/std/experimental/language.support/support.coroutines/includes.pass.cpp
index 8fc7b4cc8..440ffa113 100644
--- a/test/std/experimental/language.support/support.coroutines/includes.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/includes.pass.cpp
@@ -15,10 +15,11 @@
 
 #include <experimental/coroutine>
 
-int main(){
+int main(int, char**) {
   // std::nothrow is not implicitly defined by the compiler when the include is
   // missing, unlike other parts of <new>. Therefore we use std::nothrow to
   // test for #include <new>
   (void)std::nothrow;
 
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
index 885137e76..35a98b789 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
@@ -20,9 +20,11 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> T;
     static_assert(!std::is_copy_assignable<T>::value, "");
     static_assert(!std::is_move_assignable<T>::value, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
index 1500f641d..ce3c9be10 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
@@ -20,7 +20,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     {
@@ -44,4 +44,6 @@ int main()
         assert(a.resource() == a2.resource());
         assert(a2.resource() == (ex::memory_resource*)42);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
index acec1a02d..6a60021e5 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
@@ -23,7 +23,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     {
         static_assert(
@@ -45,4 +45,6 @@ int main()
         assert(a.resource() == &R1);
         assert(a2.resource() == ex::new_delete_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
index 0e963117d..77748ea12 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     {
         typedef ex::polymorphic_allocator<void> A;
@@ -41,4 +41,6 @@ int main()
         A const a(&R);
         assert(a.resource() == &R);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
index c0a685615..21a56f67b 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<char> A2;
@@ -53,4 +53,6 @@ int main()
         assert(a.resource() == a2.resource());
         assert(a2.resource() == (ex::memory_resource*)42);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
index 84672d3b3..6877885a7 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
@@ -26,7 +26,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<int> A2;
@@ -130,4 +130,6 @@ int main()
         assert(d1.checkIsEqualCalledEq(0));
         assert(d2.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
index 7ce6ec1fc..39bc3e28f 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
@@ -26,7 +26,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<int> A2;
@@ -101,4 +101,6 @@ int main()
         assert(d1.checkIsEqualCalledEq(0));
         assert(d2.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
index a489e865c..ce9c82fb4 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
@@ -80,7 +80,7 @@ void testAllocForSizeThrows() {
 }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-int main()
+int main(int, char**)
 {
     {
         ex::polymorphic_allocator<int> a;
@@ -108,4 +108,6 @@ int main()
         testAllocForSizeThrows<13>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
index 66a072fb2..739d95126 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
@@ -34,7 +34,7 @@ struct default_constructible
     int x{0};
 };
 
-int main()
+int main(int, char**)
 {
     // pair<default_constructible, default_constructible> as T()
     {
@@ -49,4 +49,6 @@ int main()
         assert(ptr->second.x == 42);
         std::free(ptr);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
index 16309d662..862657a31 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
@@ -118,7 +118,7 @@ void test_pmr_not_uses_allocator(std::pair<TT, UU> const& p)
 template <class Tp>
 struct Print;
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -139,4 +139,6 @@ int main()
         test_pmr_not_uses_allocator<PMR>(p);
         test_pmr_uses_allocator<PMA>(p);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
index 91e96cf39..479587ed0 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
@@ -114,7 +114,7 @@ void test_pmr_not_uses_allocator(std::pair<TT, UU>&& p)
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -135,4 +135,6 @@ int main()
         test_pmr_not_uses_allocator<PMR>(std::move(p));
         test_pmr_uses_allocator<PMA>(std::move(p));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
index d6fa37b84..9f558581a 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
@@ -121,7 +121,7 @@ void test_pmr_not_uses_allocator(TT&& t, UU&& u)
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -140,4 +140,6 @@ int main()
         test_pmr_not_uses_allocator<PMR>(std::move(x), y);
         test_pmr_uses_allocator<PMA>(std::move(x), y);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
index f043c301e..91f315468 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -111,7 +111,7 @@ void test_pmr_not_uses_allocator(std::tuple<TTypes...> ttuple, std::tuple<UTypes
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -159,4 +159,6 @@ int main()
         test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
         test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
index dc19ae170..4f30d13c8 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
@@ -120,7 +120,7 @@ void test_evil()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_evil<WidgetV0, WidgetV0>();
     test_evil<WidgetV0, WidgetV1>();
@@ -138,4 +138,6 @@ int main()
     test_evil<WidgetV3, WidgetV1>();
     test_evil<WidgetV3, WidgetV2>();
     test_evil<WidgetV3, WidgetV3>();
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
index adfe683e2..526988199 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
@@ -187,7 +187,7 @@ void test_non_pmr_uses_alloc(AllocObj const& A, Args&&... args)
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ET = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -223,4 +223,6 @@ int main()
         test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue, std::move(value));
         test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue, std::move(value));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
index 8dadb1773..022478da7 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
@@ -41,7 +41,7 @@ void testForSizeAndAlign() {
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         ex::polymorphic_allocator<int> a;
@@ -58,4 +58,6 @@ int main()
         testForSizeAndAlign<73, MA>();
         testForSizeAndAlign<13, MA>();
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
index 75c04c53c..0a1b60dc2 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
@@ -32,7 +32,7 @@ struct destroyable
     ~destroyable() { --count; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<double> A;
     {
@@ -48,4 +48,6 @@ int main()
         assert(count == 0);
         std::free(ptr);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
index 11d392f59..b05f2b292 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A;
     {
@@ -53,4 +53,6 @@ int main()
         assert(a.resource() == mptr);
         assert(a.resource() == ex::get_default_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
index 7c7c07d52..92beab473 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A;
     {
@@ -49,4 +49,6 @@ int main()
         assert(other.resource() == mptr);
         assert(a.resource() == nullptr);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
index 98c4bdd4f..796f3c353 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
index 98c4bdd4f..796f3c353 100644
--- a/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
index 09249219f..4466b2b4e 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
@@ -21,7 +21,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef CountingAllocator<char> AllocT;
     typedef ex::resource_adaptor<AllocT> R;
@@ -49,4 +49,6 @@ int main()
         assert(P.move_constructed == 0);
         assert(r.get_allocator() == a);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
index df54ba503..b6af85151 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
@@ -21,7 +21,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef CountingAllocator<char> AllocT;
     typedef ex::resource_adaptor<AllocT> R;
@@ -40,4 +40,6 @@ int main()
         assert(P.move_constructed == 1);
         assert(r.get_allocator() == AllocT{P});
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
index 5550e4fa5..53481ab39 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
@@ -23,7 +23,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     {
         typedef CountingAllocator<char> AllocT; // Not default constructible
@@ -36,4 +36,6 @@ int main()
         static_assert(std::is_default_constructible<R>::value, "");
         R r; ((void)r);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
index b2dc3aae1..806fa6e95 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
@@ -106,9 +106,11 @@ void check_alloc_max_size() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     check_allocate_deallocate<CountingAllocator<char>>();
     check_allocate_deallocate<MinAlignedAllocator<char>>();
     check_alloc_max_size();
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
index baa8e17c5..71c36693c 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
@@ -23,7 +23,7 @@
 using std::size_t;
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
 
     typedef CountingAllocator<char> Alloc1;
@@ -79,4 +79,6 @@ int main()
         assert(!m1.is_equal(m2));
         assert(!m2.is_equal(m1));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
index a47968e90..873dfd939 100644
--- a/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
@@ -19,7 +19,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::resource_adaptor<std::allocator<void>> R;
     typedef ex::resource_adaptor<std::allocator<long>> R2;
@@ -35,4 +35,6 @@ int main()
         static_assert(std::is_copy_assignable<R>::value, "");
         static_assert(std::is_move_assignable<R>::value, "");
    }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
index 80e3c6e2e..2aba4431e 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdDeque = std::deque<int, pmr::polymorphic_allocator<int>>;
     using PmrDeque = pmr::deque<int>;
     static_assert(std::is_same<StdDeque, PmrDeque>::value, "");
     PmrDeque d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
index 5fc71fb9a..66adb0b51 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdForwardList = std::forward_list<int, pmr::polymorphic_allocator<int>>;
     using PmrForwardList = pmr::forward_list<int>;
     static_assert(std::is_same<StdForwardList, PmrForwardList>::value, "");
     PmrForwardList d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
index 3a13f1303..2884a3fbb 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdList = std::list<int, pmr::polymorphic_allocator<int>>;
     using PmrList = pmr::list<int>;
     static_assert(std::is_same<StdList, PmrList>::value, "");
     PmrList d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
index 507aaf7b7..5b221c539 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
@@ -30,7 +30,7 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using K = int;
     using V = char;
@@ -65,4 +65,6 @@ int main()
         pmr::multimap<int, int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
index ffc6f4239..95f6d6f0c 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
@@ -40,7 +40,7 @@ void test_match_result_typedef() {
     static_assert(std::is_same<PmrMR, PmrTypedef>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         test_match_result_typedef<const char*, pmr::cmatch>();
@@ -53,4 +53,6 @@ int main()
         pmr::smatch s;
         assert(s.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
index 42b6f33eb..4ee12d61a 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
@@ -30,7 +30,7 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using V = char;
     using DC = std::less<V>;
@@ -63,4 +63,6 @@ int main()
         pmr::multiset<int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
index 081466dbc..3a730fafe 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
@@ -50,7 +50,7 @@ void test_basic_string_alias() {
     static_assert(std::is_same<StdStr, PmrStr>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         test_string_typedef<char,     pmr::string>();
@@ -69,4 +69,6 @@ int main()
         pmr::string s;
         assert(s.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
index 190cfd40f..8b07d68a0 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
@@ -36,7 +36,7 @@ struct MyHash : std::hash<T> {};
 template <class T>
 struct MyPred : std::equal_to<T> {};
 
-int main()
+int main(int, char**)
 {
     using K = int;
     using V = char;
@@ -83,4 +83,6 @@ int main()
         pmr::unordered_multimap<int, int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
index 7a795d08f..c4238dee1 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
@@ -36,7 +36,7 @@ struct MyHash : std::hash<T> {};
 template <class T>
 struct MyPred : std::equal_to<T> {};
 
-int main()
+int main(int, char**)
 {
     using V = char;
     using DH = std::hash<V>;
@@ -81,4 +81,6 @@ int main()
         pmr::unordered_multiset<int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp b/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
index ea8d11e14..a5c0e8bbd 100644
--- a/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdVector = std::vector<int, pmr::polymorphic_allocator<int>>;
     using PmrVector = pmr::vector<int>;
     static_assert(std::is_same<StdVector, PmrVector>::value, "");
     PmrVector d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
index 91a9027a2..c3bf1a2fc 100644
--- a/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
@@ -36,7 +36,7 @@
 
 using namespace std::experimental::pmr;
 
-int main() {
+int main(int, char**) {
     TestResource R;
     { // Test (A) and (B)
         memory_resource* p = get_default_resource();
@@ -70,4 +70,6 @@ int main() {
         static_assert(noexcept(set_default_resource(nullptr)),
                       "set_default_resource() must be noexcept");
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
index 958490d78..da340d7a0 100644
--- a/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
@@ -92,10 +92,12 @@ void test_allocate_deallocate()
 
 }
 
-int main()
+int main(int, char**)
 {
     static_assert(noexcept(ex::new_delete_resource()), "Must be noexcept");
     test_return();
     test_equality();
     test_allocate_deallocate();
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp b/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
index aab29728f..f7111b493 100644
--- a/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
@@ -108,10 +108,12 @@ void test_deallocate()
     assert(globalMemCounter.checkDeleteArrayCalledEq(0));
 }
 
-int main()
+int main(int, char**)
 {
     test_return();
     test_equality();
     test_allocate();
     test_deallocate();
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/construct.fail.cpp b/test/std/experimental/memory/memory.resource/construct.fail.cpp
index d23f58350..f4d57be8d 100644
--- a/test/std/experimental/memory/memory.resource/construct.fail.cpp
+++ b/test/std/experimental/memory/memory.resource/construct.fail.cpp
@@ -18,7 +18,9 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     ex::memory_resource m; // expected-error {{variable type 'ex::memory_resource' is an abstract class}}
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
index 774e6c7e7..f9d4d5beb 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
@@ -21,7 +21,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     // check return types
     {
@@ -72,4 +72,6 @@ int main()
         assert(r1.checkIsEqualCalledEq(1));
         assert(r2.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
index c9ce39138..037bb1a96 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
@@ -20,7 +20,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     // check return types
     {
@@ -71,4 +71,6 @@ int main()
         assert(!(mr2 != mr1));
         assert(r1.checkIsEqualCalledEq(0));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
index 98c4bdd4f..796f3c353 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
index 15db1b365..faa3a252e 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
@@ -18,9 +18,11 @@
 
 namespace ex = std::experimental::pmr;
 
-int main() {
+int main(int, char**) {
     ex::memory_resource *m = ex::new_delete_resource();
     m->do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
     m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
     m->do_is_equal(*m); // expected-error{{'do_is_equal' is a protected member}}
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
index 77aa1da3c..38f49743c 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
@@ -31,7 +31,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     TestResource R(42);
     auto& P = R.getController();
@@ -85,4 +85,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
index c76036811..e8c2d5bff 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
@@ -30,7 +30,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     NullResource R(42);
     auto& P = R.getController();
@@ -70,4 +70,6 @@ int main()
         assert(P.dealloc_count == 2);
         assert(P.checkDealloc(p, s, a));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
index db9156834..be5ea2fb0 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
@@ -26,7 +26,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     static_assert(
         std::has_virtual_destructor<memory_resource>::value
@@ -55,4 +55,6 @@ int main()
         assert(TR::resource_constructed == 1);
         assert(TR::resource_destructed == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp b/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
index e2ff9d9d1..f0e517870 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
@@ -28,7 +28,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     {
         memory_resource const* r1 = nullptr;
@@ -89,4 +89,6 @@ int main()
         assert(P2.checkIsEqualCalledEq(1));
         assert(P1.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
diff --git a/test/std/experimental/memory/nothing_to_do.pass.cpp b/test/std/experimental/memory/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/experimental/memory/nothing_to_do.pass.cpp
+++ b/test/std/experimental/memory/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/experimental/nothing_to_do.pass.cpp b/test/std/experimental/nothing_to_do.pass.cpp
index 98c4bdd4f..796f3c353 100644
--- a/test/std/experimental/nothing_to_do.pass.cpp
+++ b/test/std/experimental/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp b/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
index a17e96df6..6bd56d2dd 100644
--- a/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
+++ b/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
@@ -63,4 +63,6 @@ static_assert(std::is_same<ex::simd_abi::compatible<int8_t>,
                            ex::__simd_abi<ex::_StorageKind::_Array, 16>>::value,
               "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.access/default.pass.cpp b/test/std/experimental/simd/simd.access/default.pass.cpp
index 9b179f2c7..6e6e4fe9e 100644
--- a/test/std/experimental/simd/simd.access/default.pass.cpp
+++ b/test/std/experimental/simd/simd.access/default.pass.cpp
@@ -210,7 +210,9 @@ void test_access() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_access<ex::native_simd<int>>();
   test_access<ex::fixed_size_simd<int, 4>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp b/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
index 7f70c5b02..ec4a32bf9 100644
--- a/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
+++ b/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
@@ -42,4 +42,6 @@ static_assert(
         ex::simd<int64_t, ex::simd_abi::scalar>>::value,
     "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp b/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
index a01e42358..40922ce11 100644
--- a/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
+++ b/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
@@ -37,4 +37,6 @@ static_assert(
         ex::simd<float, ex::simd_abi::scalar>>::value,
     "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.cons/broadcast.pass.cpp b/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
index 2e34bb9ac..25dd8a4c5 100644
--- a/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
@@ -78,8 +78,10 @@ void test_broadcast() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_broadcast<ex::native_simd<int>>();
   test_broadcast<ex::fixed_size_simd<int, 4>>();
   test_broadcast<ex::fixed_size_simd<int, 15>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/simd/simd.cons/default.pass.cpp b/test/std/experimental/simd/simd.cons/default.pass.cpp
index 2e64a8219..6eebe0ec0 100644
--- a/test/std/experimental/simd/simd.cons/default.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/default.pass.cpp
@@ -18,10 +18,12 @@
 
 namespace ex = std::experimental::parallelism_v2;
 
-int main() {
+int main(int, char**) {
   static_assert(ex::native_simd<int32_t>().size() > 0, "");
   static_assert(ex::fixed_size_simd<int32_t, 4>().size() == 4, "");
   static_assert(ex::fixed_size_simd<int32_t, 5>().size() == 5, "");
   static_assert(ex::fixed_size_simd<int32_t, 1>().size() == 1, "");
   static_assert(ex::fixed_size_simd<char, 32>().size() == 32, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/simd/simd.cons/generator.pass.cpp b/test/std/experimental/simd/simd.cons/generator.pass.cpp
index 542715de6..19880e9d3 100644
--- a/test/std/experimental/simd/simd.cons/generator.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/generator.pass.cpp
@@ -82,9 +82,11 @@ void test_generator() {
   }
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   assert(ex::native_simd<int32_t>::size() >= 4);
   test_generator<ex::native_simd<int32_t>>();
   test_generator<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/simd/simd.cons/load.pass.cpp b/test/std/experimental/simd/simd.cons/load.pass.cpp
index 3056e47fd..9440d5aef 100644
--- a/test/std/experimental/simd/simd.cons/load.pass.cpp
+++ b/test/std/experimental/simd/simd.cons/load.pass.cpp
@@ -107,11 +107,13 @@ void test_converting_load_ctor() {
   assert(a[3] == 8);
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   assert(ex::native_simd<int32_t>::size() >= 4);
   test_load_ctor<ex::native_simd<int32_t>>();
   test_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
   test_converting_load_ctor<ex::native_simd<int32_t>>();
   test_converting_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/simd/simd.mem/load.pass.cpp b/test/std/experimental/simd/simd.mem/load.pass.cpp
index 9bda07ee9..1a56161c5 100644
--- a/test/std/experimental/simd/simd.mem/load.pass.cpp
+++ b/test/std/experimental/simd/simd.mem/load.pass.cpp
@@ -111,11 +111,13 @@ void test_converting_load() {
   assert(a[3] == 8);
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   assert(ex::native_simd<int32_t>::size() >= 4);
   test_load<ex::native_simd<int32_t>>();
   test_load<ex::fixed_size_simd<int32_t, 4>>();
   test_converting_load<ex::native_simd<int32_t>>();
   test_converting_load<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/simd/simd.mem/store.pass.cpp b/test/std/experimental/simd/simd.mem/store.pass.cpp
index 3faf40000..3cc3d1fa1 100644
--- a/test/std/experimental/simd/simd.mem/store.pass.cpp
+++ b/test/std/experimental/simd/simd.mem/store.pass.cpp
@@ -85,10 +85,12 @@ void test_converting_store() {
   assert(buffer[3] == 8.);
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   test_store<ex::native_simd<int32_t>>();
   test_store<ex::fixed_size_simd<int32_t, 4>>();
   test_converting_store<ex::native_simd<int32_t>>();
   test_converting_store<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
diff --git a/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp b/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
index a2206780f..2bf28dc8a 100644
--- a/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
@@ -28,4 +28,6 @@ static_assert(std::is_same<ex::abi_for_size_t<int, 4>,
                            ex::simd_abi::fixed_size<4>>::value,
               "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp b/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
index f07fca829..db98dae2b 100644
--- a/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
@@ -109,4 +109,6 @@ static_assert(!ex::is_abi_tag_v<ex::simd<float>>, "");
 static_assert(!ex::is_abi_tag_v<ex::simd_mask<int>>, "");
 static_assert(!ex::is_abi_tag_v<ex::simd_mask<float>>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.traits/is_simd.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
index 46326ab5f..c465f0de6 100644
--- a/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
@@ -125,4 +125,6 @@ static_assert(!ex::is_simd_v<ex::simd_mask<int>>, "");
 static_assert(!ex::is_simd_v<ex::simd_mask<float>>, "");
 static_assert(!ex::is_simd_v<UserType>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
index d91d906ca..5fa208a3b 100644
--- a/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
@@ -47,4 +47,6 @@ static_assert(!ex::is_simd_flag_type_v<UserType>, "");
 static_assert(!ex::is_simd_flag_type_v<ex::simd<int8_t>>, "");
 static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<int8_t>>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
index 5346afef5..348f2bfdf 100644
--- a/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
+++ b/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
@@ -148,4 +148,6 @@ static_assert(!ex::is_simd_mask_v<ex::simd<int>>, "");
 static_assert(!ex::is_simd_mask_v<ex::simd<float>>, "");
 static_assert(!ex::is_simd_mask_v<UserType>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
index 658bf0c12..3ad12b617 100644
--- a/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
@@ -33,7 +33,9 @@ void test() {
     static_assert( std::is_same<Res, typename ex::detected_or_t<double, hasFoo, T>      >::value, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, int>();
     test<noFoo, double>();
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
index 7d3304fbc..ebb7ecc7d 100644
--- a/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
@@ -40,8 +40,10 @@ void test() {
     static_assert( std::is_same<Res, typename ex::detected_t<callFoo, T>>::value, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, int>();
     test<noFoo, ex::nonesuch>();  // lookup failure returns nonesuch
     test<wrongFoo, std::string>();
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
index 24c9d7011..60b1acae8 100644
--- a/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
@@ -29,8 +29,10 @@ void test() {
     static_assert( b == ex::is_detected_v<copy_assign_t, T>, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<int, true>();
     test<std::string, true>();
     test<not_assignable, false>();
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
index a6252b245..0944cb2d0 100644
--- a/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
@@ -41,9 +41,11 @@ void test() {
     static_assert( b == ex::is_detected_convertible_v<int, callFoo, T>, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, true>();
     test<noFoo, false>();
     test<wrongFoo, false>();
     test<convertibleFoo, true>();
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp b/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
index c888d436b..c31564032 100644
--- a/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
+++ b/test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
@@ -40,9 +40,11 @@ void test() {
     static_assert( b == ex::is_detected_exact_v<int, callFoo, T>, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, true>();
     test<noFoo, false>();
     test<wrongFoo, false>();
     test<convertibleFoo, false>();
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/nothing_to_do.pass.cpp b/test/std/experimental/utilities/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/experimental/utilities/nothing_to_do.pass.cpp
+++ b/test/std/experimental/utilities/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
index 481fd4f8f..078c8c7f0 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
@@ -20,4 +20,6 @@ using std::experimental::propagate_const;
 
 typedef propagate_const<X> P;
 
-int main() { static_assert(!std::is_assignable<P, const P &>::value, ""); }
+int main(int, char**) { static_assert(!std::is_assignable<P, const P &>::value, ""); 
+  return 0;
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
index 7a0fb47eb..512b59981 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<CopyConstructibleFromX> PY;
 
@@ -30,4 +30,6 @@ int main() {
   p = x1;
 
   assert(*p==1);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
index 9b6e70458..0da532ab4 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
@@ -21,4 +21,6 @@ using std::experimental::propagate_const;
 typedef propagate_const<X> PX;
 typedef propagate_const<CopyConstructibleFromX> PY;
 
-int main() { static_assert(!std::is_assignable<PY, const PX &>::value, ""); }
+int main(int, char**) { static_assert(!std::is_assignable<PY, const PX &>::value, ""); 
+  return 0;
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
index d46180ee6..896ef9c90 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -30,4 +30,6 @@ int main() {
   p = x1;
 
   assert(*p==1);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
index 3aff45980..f1546afcc 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -28,4 +28,6 @@ int main() {
   p2=std::move(p1);
 
   assert(*p2==1);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
index 5fe39a435..dfff0bc93 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> PX;
   typedef propagate_const<MoveConstructibleFromX> PY;
@@ -29,4 +29,6 @@ int main() {
   py1=std::move(px2);
 
   assert(*py1==2);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
index b99a25121..894910eaa 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> PX;
   typedef propagate_const<MoveConstructibleFromX> PY;
@@ -29,4 +29,6 @@ int main() {
   py1=std::move(px2);
 
   assert(*py1==2);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
index 10dc724ab..24e27cb6b 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
@@ -20,8 +20,10 @@ using std::experimental::propagate_const;
 
 typedef propagate_const<ExplicitCopyConstructibleFromX> P;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<P, X>::value, "");
   static_assert(std::is_constructible<P, X>::value, "");
+
+  return 0;
 }
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
index ec0ad47e7..9cb325db0 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
@@ -25,7 +25,9 @@ void f(const P& p)
   assert(*p==2);
 }
 
-int main() {
+int main(int, char**) {
   f(X(2));
+
+  return 0;
 }
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
index 0320161ba..e440245b5 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
@@ -21,5 +21,7 @@ using std::experimental::propagate_const;
 typedef propagate_const<X> PX;
 typedef propagate_const<CopyConstructibleFromX> PY;
 
-int main() { static_assert(!std::is_constructible<PX, PY>::value, ""); }
+int main(int, char**) { static_assert(!std::is_constructible<PX, PY>::value, ""); 
+  return 0;
+}
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
index aa4f1a3ed..3166ebe70 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
@@ -21,7 +21,9 @@ using std::experimental::propagate_const;
 typedef propagate_const<X> PX;
 typedef propagate_const<ExplicitMoveConstructibleFromX> PY;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<PY, PX &&>::value, "");
   static_assert(std::is_constructible<PY, PX &&>::value, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
index 77f8791a3..ea1ac4262 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
@@ -21,10 +21,12 @@ using std::experimental::propagate_const;
 typedef propagate_const<MoveConstructibleFromX> PY;
 typedef propagate_const<X> PX;
 
-int main() {
+int main(int, char**) {
   PX px(1);
   PY py(std::move(px));
 
   assert(*py==1);
+
+  return 0;
 }
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
index 0e992a69b..7c0558f39 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
@@ -20,4 +20,6 @@ using std::experimental::propagate_const;
 
 typedef propagate_const<X> P;
 
-int main() { static_assert(!std::is_constructible<P, const P &>::value, ""); }
+int main(int, char**) { static_assert(!std::is_constructible<P, const P &>::value, ""); 
+  return 0;
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
index 45a3bd363..aee637620 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
@@ -20,8 +20,10 @@ using std::experimental::propagate_const;
 
 typedef propagate_const<ExplicitX> P;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<P, int>::value, "");
   static_assert(std::is_constructible<P, int>::value, "");
+
+  return 0;
 }
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
index b9f6bad69..93e50578a 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
@@ -24,4 +24,6 @@ void f(const P&)
 {
 }
 
-int main() { f(2); }
+int main(int, char**) { f(2); 
+  return 0;
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
index 6badeeede..662a605f4 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   P p1(2);
   P p2(std::move(p1));
   assert(*p2 == 2);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
index 8dffebafa..4e47bac37 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
@@ -27,7 +27,9 @@ constexpr P f()
   return p;
 }
 
-int main() {
+int main(int, char**) {
   constexpr P p = f();
   static_assert(*p==2,"");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
index 53d378391..6ce5d407c 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
@@ -20,4 +20,6 @@ using std::experimental::propagate_const;
 
 typedef propagate_const<X> P;
 
-int main() { static_assert(!std::is_convertible<P, int *>::value, ""); }
+int main(int, char**) { static_assert(!std::is_convertible<P, int *>::value, ""); 
+  return 0;
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
index 04fe4add1..1a12c3bdd 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
@@ -27,7 +27,9 @@ constexpr P f()
   return p;
 }
 
-int main() {
+int main(int, char**) {
   constexpr P p = f();
   static_assert(*(p.get())==2,"");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
index d8ea66e8d..bdc6c6937 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
@@ -27,7 +27,9 @@ constexpr P f()
   return p;
 }
 
-int main() {
+int main(int, char**) {
   constexpr P p = f();
   static_assert(*(p.operator->())==2,"");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
index 87b688909..46244b391 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<XWithImplicitIntStarConversion> P;
 
@@ -31,4 +31,6 @@ int main() {
   *ptr_1 = 2;
 
   assert(*ptr_1==2);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
index c0a5e1e44..758bca469 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   constexpr P p(1);
 
   static_assert(*p==1,"");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
index b7dd8f843..1f98f03d2 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
@@ -20,6 +20,8 @@ using std::experimental::propagate_const;
 
 typedef propagate_const<X> P;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<const P, const int *>::value, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
index f424fae64..71aea68ed 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   constexpr P p(1);
 
   static_assert(*(p.get())==1, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
index 14ba32387..dcb1b9245 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   constexpr P p(1);
 
   static_assert(*(p.operator->())==1,"");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
index 8c0cb02fc..bfd295a1f 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
@@ -24,4 +24,6 @@ constexpr P p(1);
 
 constexpr const int *ptr_1 = p;
 
-int main() { assert(*ptr_1 == 1); }
+int main(int, char**) { assert(*ptr_1 == 1); 
+  return 0;
+}
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
index e6b94957f..03b32dd0e 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
@@ -21,11 +21,13 @@ using std::experimental::propagate_const;
 bool swap_called = false;
 void swap(X &, X &) { swap_called = true; }
 
-int main() {
+int main(int, char**) {
   typedef propagate_const<X> P;
   P p1(1);
   P p2(2);
   p1.swap(p2);
   assert(swap_called);
+
+  return 0;
 }
 
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
index 76c683458..28ac9c224 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
@@ -31,7 +31,7 @@ template <> struct hash<X>
 };
 } // namespace std
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -40,4 +40,6 @@ int main() {
   auto h = std::hash<P>();
 
   assert(h(p)==99);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
index 40f4ae7d5..85e400504 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
@@ -20,7 +20,7 @@ using std::experimental::propagate_const;
 
 constexpr bool operator==(const X &x1, const X &x2) { return x1.i_ == x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -32,4 +32,6 @@ int main() {
 
   assert(c(p1_1,p2_1));
   assert(!c(p1_1,p3_2));
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
index f019f07d1..ab7b5e9a2 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
@@ -20,7 +20,7 @@ using std::experimental::propagate_const;
 
 constexpr bool operator>(const X &x1, const X &x2) { return x1.i_ > x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@ int main() {
   assert(!c(p2_1,p1_1));
   assert(!c(p1_1,p3_2));
   assert(c(p3_2,p1_1));
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
index 8f0e0d8cd..f30e0e9d2 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
@@ -20,7 +20,7 @@ using std::experimental::propagate_const;
 
 constexpr bool operator>=(const X &x1, const X &x2) { return x1.i_ >= x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@ int main() {
   assert(c(p2_1,p1_1));
   assert(!c(p1_1,p3_2));
   assert(c(p3_2,p1_1));
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
index 584f52ba6..75afd95e1 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
@@ -20,7 +20,7 @@ using std::experimental::propagate_const;
 
 constexpr bool operator<(const X &x1, const X &x2) { return x1.i_ < x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@ int main() {
   assert(!c(p2_1,p1_1));
   assert(c(p1_1,p3_2));
   assert(!c(p3_2,p1_1));
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
index 4eb25db29..4f6523a32 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
@@ -20,7 +20,7 @@ using std::experimental::propagate_const;
 
 constexpr bool operator<=(const X &x1, const X &x2) { return x1.i_ <= x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@ int main() {
   assert(c(p2_1,p1_1));
   assert(c(p1_1,p3_2));
   assert(!c(p3_2,p1_1));
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
index 52eadc4b3..1c303ae28 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
@@ -20,7 +20,7 @@ using std::experimental::propagate_const;
 
 constexpr bool operator!=(const X &x1, const X &x2) { return x1.i_ != x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -32,4 +32,6 @@ int main() {
 
   assert(!c(p1_1,p2_1));
   assert(c(p1_1,p3_2));
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
index 696330a42..dafc355a4 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool operator==(const nullptr_t &, const X &) {
   return false;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -60,4 +60,6 @@ int main() {
 
   static_assert(!(p1_1==nullptr),"");
   static_assert(!(nullptr==p1_1),"");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
index 8c214f745..36f374730 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
@@ -24,7 +24,7 @@ constexpr bool operator>=(const X &lhs, const X &rhs) {
   return lhs.i_ >= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -50,4 +50,6 @@ int main() {
   static_assert(x1_1 >= p2_1, "");
   static_assert(!(x1_1 >= p3_2), "");
   static_assert(x3_2 >= p1_1, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
index fb6799785..6abadb39b 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
@@ -24,7 +24,7 @@ constexpr bool operator>(const X &lhs, const X &rhs) {
   return lhs.i_ > rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -46,4 +46,6 @@ int main() {
 
   static_assert(!(x1_1 > p2_1), "");
   static_assert(x3_2 > p1_1, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
index a1d5b3d9e..703faed74 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
@@ -24,7 +24,7 @@ constexpr bool operator<=(const X &lhs, const X &rhs) {
   return lhs.i_ <= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -51,4 +51,6 @@ int main() {
   static_assert(x1_1 <= p3_2, "");
   static_assert(!(x3_2 <= p1_1), "");
 
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
index 00bf157d9..7481418d3 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
@@ -24,7 +24,7 @@ constexpr bool operator<(const X &lhs, const X &rhs) {
   return lhs.i_ < rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -46,4 +46,6 @@ int main() {
 
   static_assert(!(p1_1 < x1_1), "");
   static_assert(p1_1 < x3_2, "");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
index ba30912dd..ebfc62315 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool operator!=(const nullptr_t &, const X &) {
   return true;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -58,4 +58,6 @@ int main() {
 
   static_assert(p1_1!=nullptr,"");
   static_assert(nullptr!=p1_1,"");
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
index 1df35dd88..84923f78d 100644
--- a/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
+++ b/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
@@ -21,10 +21,12 @@ using std::experimental::propagate_const;
 bool swap_called = false;
 void swap(X &, X &) { swap_called = true; }
 
-int main() {
+int main(int, char**) {
   typedef propagate_const<X> P;
   P p1(1);
   P p2(2);
   swap(p1, p2);
   assert(swap_called);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp b/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
index 9c3ac0cc9..36bf4f793 100644
--- a/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
+++ b/test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
@@ -10,8 +10,10 @@
 
 #include <experimental/utility>
 
-int main()
+int main(int, char**)
 {
   std::experimental::erased_type e;
   ((void)e);
+
+  return 0;
 }
diff --git a/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp b/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
index 45140f333..ddf053f24 100644
--- a/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
+++ b/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
@@ -14,6 +14,8 @@
 #   error "<experimental/utility> must include <utility>"
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp b/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
index 675c57516..e9e32bb67 100644
--- a/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
+++ b/test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
@@ -877,7 +877,7 @@ template <class T> void test()
     ((void)t); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<std::int8_t >();
     test<std::int16_t>();
@@ -927,4 +927,6 @@ int main()
     static_assert((std::is_same<decltype(std::strtoumax("", (char**)0, 0)), std::uintmax_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstoimax(L"", (wchar_t**)0, 0)), std::intmax_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstoumax(L"", (wchar_t**)0, 0)), std::uintmax_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/c.files/cstdio.pass.cpp b/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
index 95a5cb695..af8dc97a5 100644
--- a/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
+++ b/test/std/input.output/file.streams/c.files/cstdio.pass.cpp
@@ -85,7 +85,7 @@
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-int main()
+int main(int, char**)
 {
     std::FILE* fp = 0;
     std::fpos_t fpos = std::fpos_t();
@@ -154,4 +154,6 @@ int main()
     static_assert((std::is_same<decltype(std::puts("")), int>::value), "");
     static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/c.files/gets.fail.cpp b/test/std/input.output/file.streams/c.files/gets.fail.cpp
index 0772dc9f0..dae0e42ff 100644
--- a/test/std/input.output/file.streams/c.files/gets.fail.cpp
+++ b/test/std/input.output/file.streams/c.files/gets.fail.cpp
@@ -13,7 +13,9 @@
 
 #include <cstdio>
 
-int main()
+int main(int, char**)
 {
     (void) std::gets((char *) NULL);
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
index b6890b871..9bfcec0a4 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -50,4 +50,6 @@ int main()
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
index 0acda35b0..a397e6cc1 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -52,4 +52,6 @@ int main()
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
index 6fd1d2bb4..f23c119af 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -52,4 +52,6 @@ int main()
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
index d9230b045..5efbb03c8 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::filebuf f;
@@ -26,4 +26,6 @@ int main()
         std::wfilebuf f;
         assert(!f.is_open());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
index ad4d37dad..922e514d7 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -50,4 +50,6 @@ int main()
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
index 7f7ce344f..ea244e1a3 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
@@ -19,7 +19,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
 
   fs::path p = get_temp_file_name();
   {
@@ -52,4 +52,6 @@ int main() {
     assert(f.sbumpc() == L'3');
   }
   remove(p.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
index fc3dd6d01..bd662a9f7 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
@@ -14,7 +14,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -47,4 +47,6 @@ int main()
         assert(f.sbumpc() == L'3');
     }
     remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
index 0aeb505c7..6636a4223 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
@@ -36,7 +36,7 @@ struct test_buf
     virtual int_type overflow(int_type c = traits_type::eof()) {return base::overflow(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test_buf<char> f;
@@ -140,4 +140,6 @@ int main()
         assert(f.sbumpc() == -1);
     }
     std::remove("overflow.dat");
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
index e711b0c9b..728eec293 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
@@ -32,7 +32,7 @@ struct test_buf
     virtual int_type pbackfail(int_type c = traits_type::eof()) {return base::pbackfail(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test_buf<char> f;
@@ -60,4 +60,6 @@ int main()
             assert(f.sgetc() == '2');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
index 9126b3396..6f50357a0 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         char buf[10];
@@ -62,4 +62,6 @@ int main()
         assert(f.sgetc() == L'l');
     }
     std::remove("seekoff.dat");
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
index 8859b0796..47760a916 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
@@ -36,7 +36,7 @@ struct test_buf
     virtual int_type underflow() {return base::underflow();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test_buf<char> f;
@@ -121,4 +121,6 @@ int main()
         assert(f.sbumpc() == 0x4E53);
         assert(f.sbumpc() == static_cast<Traits::int_type>(-1));
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp b/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
index e0c95f50a..40c010f6f 100644
--- a/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_streambuf<char>, std::basic_filebuf<char> >::value), "");
     static_assert((std::is_same<std::basic_filebuf<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::basic_filebuf<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_filebuf<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_filebuf<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
index 312a68d83..7c94de924 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
@@ -35,7 +35,7 @@ std::pair<std::string, std::string> get_temp_file_names() {
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -87,4 +87,6 @@ int main()
     }
     std::remove(temp1.c_str());
     std::remove(temp2.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
index 4ee860a8e..d2cc6ce72 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
index 5a2d826be..071ca5d85 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
@@ -37,7 +37,7 @@ std::pair<std::string, std::string> get_temp_file_names() {
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -89,4 +89,6 @@ int main()
     }
     std::remove(temp1.c_str());
     std::remove(temp2.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
index ede9fd239..b38bbb443 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         std::fstream fs;
@@ -24,4 +24,6 @@ int main()
     {
         std::wfstream fs;
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
index a213cc643..fb639f1c5 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -44,4 +44,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
index f63ae6bdd..d86b4b6cc 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
@@ -23,7 +23,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   fs::path p = get_temp_file_name();
   {
     std::fstream fs(p, std::ios_base::in | std::ios_base::out |
@@ -45,4 +45,6 @@ int main() {
     assert(x == 3.25);
   }
   std::remove(p.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
index 07a6a4113..4cade955b 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -40,4 +40,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
index 36546035c..15a2c7023 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -42,4 +42,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
index 818f73be8..94a06c467 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -38,4 +38,6 @@ int main()
         assert(!fs.is_open());
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
index d6722076a..799829e2b 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main() {
+int main(int, char**) {
   std::filesystem::path p = get_temp_file_name();
   {
     std::fstream stream;
@@ -48,4 +48,6 @@ int main() {
     assert(x == 3.25);
   }
   std::remove(p.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
index 07f5c18f5..32f1d0096 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
index 4bc436b38..90cd56117 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
index ecbc15bc3..0f39fc63b 100644
--- a/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::fstream fs;
@@ -26,4 +26,6 @@ int main()
         std::wfstream fs;
         assert(fs.rdbuf());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp b/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
index 3f81e18f4..783cfa3a7 100644
--- a/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_iostream<char>, std::basic_fstream<char> >::value), "");
     static_assert((std::is_same<std::basic_fstream<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::basic_fstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_fstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_fstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
index e30a9c060..17b88140d 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs1("test.dat");
@@ -38,4 +38,6 @@ int main()
         fs2 >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
index 9ccd54eec..d5fe0984e 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fso("test.dat");
@@ -36,4 +36,6 @@ int main()
         fs >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
index c008fe50f..c4cd592d1 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs1("test.dat");
@@ -39,4 +39,6 @@ int main()
         fs2 >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
index 896903d36..7e76d6f8a 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -24,4 +24,6 @@ int main()
     {
         std::wifstream fs;
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
index c7e389e3a..d8a58ac53 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fso("test.dat");
@@ -34,4 +34,6 @@ int main()
         fs >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
index 7d6da5b27..8a3a361bb 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   {
     fs::path p;
     static_assert(!std::is_convertible<fs::path, std::ifstream>::value,
@@ -49,4 +49,6 @@ int main() {
   // std::wifstream(const fs::path&, std::ios_base::openmode) is tested in
   // test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
   // which creates writable files.
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
index 6e0bb2984..d44b3be75 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs("test.dat");
@@ -36,4 +36,6 @@ int main()
     // std::wifstream(const char*, std::ios_base::openmode) is tested in
     // test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
     // which creates writable files.
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
index a0d90e255..c4e979e30 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs(std::string("test.dat"));
@@ -36,4 +36,6 @@ int main()
     // std::wifstream(const std::string&, std::ios_base::openmode) is tested in
     // test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
     // which creates writable files.
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
index 609ca4ac1..e72bd5487 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -34,4 +34,6 @@ int main()
         fs.close();
         assert(!fs.is_open());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
index 4432ea5c6..bce5fb97d 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
@@ -19,7 +19,7 @@
 #include <filesystem>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   {
     std::ifstream fs;
     assert(!fs.is_open());
@@ -44,4 +44,6 @@ int main() {
     fs >> c;
     assert(c == L'r');
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
index 3a12c9852..50ec53fdc 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -42,4 +42,6 @@ int main()
         fs >> c;
         assert(c == L'r');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
index e6759ed8c..155ae0e63 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -42,4 +42,6 @@ int main()
         fs >> c;
         assert(c == L'r');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
index ea64139f1..455d2274e 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs("test.dat");
@@ -28,4 +28,6 @@ int main()
         std::wfilebuf* fb = fs.rdbuf();
         assert(fb->sgetc() == L'r');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp b/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
index a3b441f93..620c39608 100644
--- a/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_istream<char>, std::basic_ifstream<char> >::value), "");
     static_assert((std::is_same<std::basic_ifstream<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::basic_ifstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ifstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ifstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
index 89e32e97f..fcfb94ecf 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
@@ -35,7 +35,7 @@ std::pair<std::string, std::string> get_temp_file_names() {
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -95,4 +95,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp2.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
index 1eba0d576..fbc3bf597 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -48,4 +48,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
index 4190db3a6..3cbf508d9 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
@@ -36,7 +36,7 @@ std::pair<std::string, std::string> get_temp_file_names() {
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -96,4 +96,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp2.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
index f87bb1e79..baa4bfe9d 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         std::ofstream fs;
@@ -24,4 +24,6 @@ int main()
     {
         std::wofstream fs;
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
index 85fcffee4..3a3e11e91 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
index bad7e4f64..254d696aa 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   fs::path p = get_temp_file_name();
   {
     static_assert(!std::is_convertible<fs::path, std::ofstream>::value,
@@ -65,4 +65,6 @@ int main() {
     assert(x == 3.25);
   }
   std::remove(p.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
index 5e4a18d1e..ce23d5e36 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
index 41e739abb..c19c278f4 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@ int main()
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
index 00a704191..3ea39985e 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -38,4 +38,6 @@ int main()
         assert(!fs.is_open());
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
index 857b6c68f..1b783f6d5 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   fs::path p = get_temp_file_name();
   {
     std::ofstream fs;
@@ -58,4 +58,6 @@ int main() {
     assert(c == L'a');
   }
   std::remove(p.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
index 689622741..5bf58814d 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@ int main()
         assert(c == L'a');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
index 6a223891a..52db618e1 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@ int main()
         assert(c == L'a');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
index 6e8f2fc36..a7b51fb35 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -32,4 +32,6 @@ int main()
         assert(fb->sputc(L'r') == L'r');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp b/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
index 1feb4214a..231807195 100644
--- a/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
+++ b/test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_ofstream<char> >::value), "");
     static_assert((std::is_same<std::basic_ofstream<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::basic_ofstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ofstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ofstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/file.streams/nothing_to_do.pass.cpp b/test/std/input.output/file.streams/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/file.streams/nothing_to_do.pass.cpp
+++ b/test/std/input.output/file.streams/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
index 106eb033f..1cb88a351 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   // Default
   {
@@ -27,4 +27,6 @@ int main() {
     directory_entry e;
     assert(e.path() == path());
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
index 856231243..0f681531a 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
@@ -19,7 +19,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   // Default
   {
@@ -28,4 +28,6 @@ int main() {
     const directory_entry e;
     assert(e.path() == path());
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
index 10e8c63b6..12158349e 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
@@ -74,7 +74,9 @@ void test_comparisons_simple() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_comparison_signatures();
   test_comparisons_simple();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
index 185b0ef4a..28bd2752e 100644
--- a/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
@@ -81,7 +81,9 @@ void test_path_conversion() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_path_method();
   test_path_conversion();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
index c318bdb33..9f60ec286 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
     {
         static_assert(std::is_nothrow_default_constructible<fs::directory_iterator>::value, "");
     }
@@ -31,4 +31,6 @@ int main() {
         const fs::directory_iterator d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp b/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
index bac693903..3932be021 100644
--- a/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
+++ b/test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
     using namespace fs;
     using D = directory_iterator;
     ASSERT_SAME_TYPE(D::value_type, directory_entry);
@@ -33,4 +33,6 @@ int main() {
     ASSERT_SAME_TYPE(D::pointer, const directory_entry*);
     ASSERT_SAME_TYPE(D::reference, const directory_entry&);
     ASSERT_SAME_TYPE(D::iterator_category, std::input_iterator_tag);
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp b/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
index 53c619bd8..74fdaaf20 100644
--- a/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
+++ b/test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_convertible.hpp"
 
 
-int main() {
+int main(int, char**) {
  using namespace fs;
   // Default ctor
   {
@@ -56,4 +56,6 @@ int main() {
     assert(f.type()  == file_type::regular);
     assert(f.permissions() == perms::owner_read);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp b/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
index 38573beac..0ee9f709b 100644
--- a/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
+++ b/test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
 
   file_status st;
@@ -45,4 +45,6 @@ int main() {
     st.permissions(perms::owner_read);
     assert(st.permissions() == perms::owner_read);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp b/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
index 676ceea8d..ec4863139 100644
--- a/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
+++ b/test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
 
   const file_status st(file_type::regular, perms::owner_read);
@@ -41,4 +41,6 @@ int main() {
                  "operation must return perms");
     assert(st.permissions() == perms::owner_read);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp b/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
index 075a4137d..d9d1a0333 100644
--- a/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
+++ b/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
@@ -94,8 +94,10 @@ void test_signatures()
   }
 }
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_base_of<std::system_error, fs::filesystem_error>::value, "");
   test_constructors();
   test_signatures();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp b/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
index de1e413be..558206d70 100644
--- a/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
@@ -97,8 +97,10 @@ void checkBeginEndBasic() {
 
 }
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   checkIteratorConcepts();
   checkBeginEndBasic(); // See path.decompose.pass.cpp for more tests.
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
index fb74c8e19..2f468e595 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
@@ -311,7 +311,7 @@ void test_sfinae()
   }
 }
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : Cases) {
@@ -335,4 +335,6 @@ int main()
     doAppendSourceAllocTest<wchar_t>(TC);
   }
   test_sfinae();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
index eb45c0981..aff89f27b 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
@@ -22,9 +22,11 @@
 #include "count_new.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   path p("abc");
   p = {};
   assert(p.native() == "");
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
index 04b8f63cb..9265c70f6 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_copy_assignable<path>::value, "");
   static_assert(!std::is_nothrow_copy_assignable<path>::value, "should not be noexcept");
@@ -32,4 +32,6 @@ int main() {
   assert(p.native() == s);
   assert(p2.native() == s);
   assert(&pref == &p2);
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
index 12422c68e..5e5fb1e0e 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
@@ -22,7 +22,7 @@
 #include "count_new.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_move_assignable<path>::value, "");
   assert(globalMemCounter.checkOutstandingNewEq(0));
@@ -38,4 +38,6 @@ int main() {
     assert(p.native() != s); // Testing moved from state
     assert(&pref == &p2);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
index edc0b2638..9c23e3b3e 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
@@ -228,7 +228,7 @@ void RunStringMoveTest(const char* Expect) {
   }
 }
 
-int main() {
+int main(int, char**) {
   for (auto const& MS : PathList) {
     RunTestCase<char>(MS);
     RunTestCase<wchar_t>(MS);
@@ -237,4 +237,6 @@ int main() {
     RunStringMoveTest(MS);
   }
   test_sfinae();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
index 41efb7513..165e62fe4 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
@@ -184,7 +184,9 @@ void test_compare_elements() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_compare_basic();
   test_compare_elements();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
index 842d70543..b074e831e 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
@@ -325,7 +325,7 @@ void test_sfinae() {
   }
 }
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : Cases) {
@@ -384,4 +384,6 @@ int main()
     doConcatECharTest<char32_t>(TC);
   }
   test_sfinae();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
index 789789779..1490c0b9f 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_copy_constructible<path>::value, "");
   static_assert(!std::is_nothrow_copy_constructible<path>::value, "should not be noexcept");
@@ -30,4 +30,6 @@ int main() {
   path p2(p);
   assert(p.native() == s);
   assert(p2.native() == s);
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
index 203c0e5ee..b31728da1 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
@@ -21,9 +21,11 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_default_constructible<path>::value, "");
   const path p;
   assert(p.empty());
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
index 4382de141..494a77c3c 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
@@ -22,7 +22,7 @@
 #include "count_new.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_move_constructible<path>::value, "");
   assert(globalMemCounter.checkOutstandingNewEq(0));
@@ -36,4 +36,6 @@ int main() {
     assert(p2.native() == s);
     assert(p.native() != s); // Testing moved from state
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
index b10d3aa88..bcb9986ce 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
@@ -117,7 +117,7 @@ void test_sfinae() {
   }
 }
 
-int main() {
+int main(int, char**) {
   for (auto const& MS : PathList) {
     RunTestCase<char>(MS);
     RunTestCase<wchar_t>(MS);
@@ -125,4 +125,6 @@ int main() {
     RunTestCase<char32_t>(MS);
   }
   test_sfinae();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp b/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
index 481ffcde6..5248f6751 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     fs::path c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
index aa511cdf0..be9cefb76 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
@@ -208,8 +208,10 @@ void decompFilenameTest()
   }
 }
 
-int main()
+int main(int, char**)
 {
   decompPathTest();
   decompFilenameTest();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
index 4d295eec5..f1e616542 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
@@ -26,7 +26,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
index 96fa1597b..7e31956ee 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
@@ -27,7 +27,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
index 7cb81ca00..707a7010f 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
@@ -33,7 +33,7 @@ MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQR
 // generic_string<C, T, A> forwards to string<C, T, A>. Tests for
 // string<C, T, A>() are in "path.native.op/string_alloc.pass.cpp".
 // generic_string is minimally tested here.
-int main()
+int main(int, char**)
 {
   using namespace fs;
   using CharT = wchar_t;
@@ -51,4 +51,6 @@ int main()
     assert(Alloc::alloc_count > 0);
     assert(Alloc::outstanding_alloc() == 1);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
index 2e33769cd..04ae673ac 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
@@ -31,7 +31,7 @@
 
 MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   auto const& MS = longString;
@@ -57,4 +57,6 @@ int main()
     std::u32string s = p.generic_u32string();
     assert(s == (const char32_t*)MS);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
index a224dddfa..01538539f 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
@@ -24,7 +24,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   {
     path p;
@@ -40,4 +40,6 @@ int main() {
     p2.clear();
     assert(p2.empty());
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
index 43393aba5..4530ef875 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
@@ -39,7 +39,7 @@ const MakePreferredTestcase TestCases[] =
     , {"\\foo\\/bar\\/baz\\"}
   };
 
-int main()
+int main(int, char**)
 {
   // This operation is an identity operation on linux.
   using namespace fs;
@@ -50,4 +50,6 @@ int main()
     assert(p.native() == TC.value);
     assert(&Ref == &p);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
index 42191379d..7cb562c22 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
@@ -57,7 +57,7 @@ const RemoveFilenameTestcase TestCases[] =
     , {"bar/../baz/./file.txt", "bar/../baz/./"}
   };
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : TestCases) {
@@ -69,4 +69,6 @@ int main()
     assert(&Ref == &p);
     assert(!p.has_filename());
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
index 70040c48a..6fec420ba 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
@@ -51,7 +51,7 @@ const ReplaceExtensionTestcase NoArgCases[] =
     , {"foo..cpp", "foo.", ""}
 };
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : TestCases) {
@@ -68,4 +68,6 @@ int main()
     assert(p == TC.expect);
     assert(&Ref == &p);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
index 363535221..8142e7907 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
@@ -47,7 +47,7 @@ const ReplaceFilenameTestcase TestCases[] =
     , {"/foo\\baz/bong", "/foo\\baz/bar", "bar"}
   };
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : TestCases) {
@@ -67,4 +67,6 @@ int main()
       ASSERT_EQ(p, p2);
     }
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
index ac623dbfc..2e9dac5e4 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
@@ -41,7 +41,7 @@ const SwapTestcase TestCases[] =
 #undef LONG_STR1
 #undef LONG_STR2
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   {
@@ -76,4 +76,6 @@ int main()
     }
     assert(p1 == Val);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
index 3f2fac696..8b35ee8c8 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
@@ -23,7 +23,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* const value = "hello world";
@@ -38,4 +38,6 @@ int main()
     assert(p.c_str() == str_value);
     assert(p.native().c_str() == p.c_str());
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
index 0d747b188..c06de9795 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
@@ -32,7 +32,7 @@
 
 MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   auto const& MS = longString;
@@ -58,4 +58,6 @@ int main()
     std::u32string s = p.u32string();
     assert(s == (const char32_t*)MS);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
index 14feaf13e..3b88b5d6c 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
@@ -22,7 +22,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* const value = "hello world";
@@ -35,4 +35,6 @@ int main()
     path p(value);
     assert(p.native() == value);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
index 53fdcc160..9f0069051 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
@@ -23,7 +23,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   using string_type = path::string_type;
@@ -42,4 +42,6 @@ int main()
     assert(s == value);
     assert(p == value);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
index 86453f8d0..4ace380b8 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
@@ -116,7 +116,7 @@ void doLongStringTest(MultiStringType const& MS) {
   /////////////////////////////////////////////////////////////////////////////
 }
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   {
@@ -133,4 +133,6 @@ int main()
     doLongStringTest<char16_t>(S);
     doLongStringTest<char32_t>(S);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp b/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
index d82578850..32c37e7f7 100644
--- a/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
@@ -28,4 +28,6 @@
 // bool is_relative() const;
 
 // tested in path.decompose
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
index 7b5082c8f..bcc4758f4 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
@@ -20,7 +20,9 @@ struct ConvToPath {
   }
 };
 
-int main() {
+int main(int, char**) {
   ConvToPath LHS, RHS;
   (void)(LHS / RHS); // expected-error {{invalid operands to binary expression}}
+
+  return 0;
 }
\ No newline at end of file
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
index 2c7042e9b..67af37686 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
@@ -20,7 +20,7 @@
 #include "filesystem_test_helper.hpp"
 
 // This is mainly tested via the member append functions.
-int main()
+int main(int, char**)
 {
   using namespace fs;
   path p1("abc");
@@ -30,4 +30,6 @@ int main()
 
   path p4 = p1 / "def";
   assert(p4 == "abc/def");
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
index 287e31523..8f1732186 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
@@ -21,7 +21,7 @@ struct ConvToPath {
   }
 };
 
-int main() {
+int main(int, char**) {
   ConvToPath LHS, RHS;
   (void)(LHS == RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS != RHS); // expected-error {{invalid operands to binary expression}}
@@ -29,4 +29,6 @@ int main() {
   (void)(LHS <= RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS > RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS >= RHS); // expected-error {{invalid operands to binary expression}}
+
+  return 0;
 }
\ No newline at end of file
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
index 3728db5f2..c61a5a025 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
@@ -10,4 +10,6 @@
 
 // The comparison operators are tested as part of [path.compare]
 // in class.path/path.members/path.compare.pass.cpp
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
index 6cf310be8..49d28daf9 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
@@ -10,4 +10,6 @@
 
 // The "hash_value" function is tested as part of [path.compare]
 // in class.path/path.members/path.compare.pass.cpp
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
index 54d0799d9..557849ca8 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
@@ -25,7 +25,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* In1 = "abcd/efg";
@@ -48,4 +48,6 @@ int main()
     path p = fs::u8path(In3, In3End);
     assert(p == In1);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
index 375e45da8..31eea925a 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
@@ -88,10 +88,12 @@ void test_LWG2989() {
   static_assert(!is_istreamable<decltype(std::wcin), std::string>::value, "");
 }
 
-int main() {
+int main(int, char**) {
   doIOTest<char>();
   doIOTest<wchar_t>();
   //doIOTest<char16_t>();
   //doIOTest<char32_t>();
   test_LWG2989();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
index 2072a9450..c5bb6bf12 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
@@ -62,7 +62,9 @@ void doIOTest() {
 }
 
 
-int main() {
+int main(int, char**) {
   doIOTest<char16_t>();
   doIOTest<char32_t>();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp b/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
index 66d854f00..51bb03e9f 100644
--- a/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
@@ -22,7 +22,7 @@
 
 
 // NOTE: this is tested in path.members/path.modifiers via the member swap.
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* value1 = "foo/bar/baz";
@@ -45,4 +45,6 @@ int main()
     assert(p1.native() == value1);
     assert(p2.native() == value2);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/class.path/synop.pass.cpp b/test/std/input.output/filesystems/class.path/synop.pass.cpp
index 9b91651e0..8aa186e32 100644
--- a/test/std/input.output/filesystems/class.path/synop.pass.cpp
+++ b/test/std/input.output/filesystems/class.path/synop.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   ASSERT_SAME_TYPE(path::value_type, char);
   ASSERT_SAME_TYPE(path::string_type, std::basic_string<path::value_type>);
@@ -34,4 +34,6 @@ int main() {
     const char* dummy = &path::preferred_separator;
     ((void)dummy);
   }
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
index 25f63a92b..b949960df 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
@@ -22,7 +22,7 @@
 
 constexpr fs::copy_options ME(int val) { return static_cast<fs::copy_options>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::copy_options E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -59,4 +59,6 @@ int main() {
           E::create_symlinks     == ME(128) &&
           E::create_hard_links   == ME(256),
         "Expected enumeration values do not match");
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
index 54574f720..43b094597 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
@@ -23,7 +23,7 @@
 
 constexpr fs::directory_options ME(int val) { return static_cast<fs::directory_options>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::directory_options E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -41,4 +41,6 @@ int main() {
         E::skip_permission_denied   == ME(2),
         "Expected enumeration values do not match");
 
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
index d2162d083..c1f16079a 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
@@ -21,7 +21,7 @@
 
 constexpr fs::file_type ME(int val) { return static_cast<fs::file_type>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::file_type E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -43,4 +43,6 @@ int main() {
           E::socket == ME(7) &&
           E::unknown == ME(8),
         "Expected enumeration values do not match");
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
index fc11e8a9c..d60225d4f 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   typedef fs::path::format E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -34,4 +34,6 @@ int main() {
           E::auto_format   != E::generic_format &&
           E::native_format != E::generic_format,
         "Expected enumeration values are not unique");
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
index 117c35875..1fd353d04 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
@@ -25,7 +25,7 @@ constexpr fs::perm_options ME(int val) {
   return static_cast<fs::perm_options>(val);
 }
 
-int main() {
+int main(int, char**) {
   typedef fs::perm_options E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -44,4 +44,6 @@ int main() {
         E::remove   == ME(4) &&
         E::nofollow == ME(8),
         "Expected enumeration values do not match");
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp b/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
index e043c87e5..93b5278fd 100644
--- a/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
+++ b/test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
@@ -23,7 +23,7 @@
 
 constexpr fs::perms ME(int val) { return static_cast<fs::perms>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::perms E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -60,4 +60,6 @@ int main() {
         E::mask         == ME(07777) &&
         E::unknown      == ME(0xFFFF),
         "Expected enumeration values do not match");
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp b/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp b/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
index 6606c9a27..e88ef1d12 100644
--- a/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
+++ b/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
@@ -39,7 +39,9 @@ void test_time_point_resolution_and_range() {
   ASSERT_SAME_TYPE(Period, std::nano);
 }
 
-int main() {
+int main(int, char**) {
   test_trivial_clock();
   test_time_point_resolution_and_range();
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp b/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
index c655490ac..94a8e13bc 100644
--- a/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
+++ b/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
@@ -25,7 +25,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
diff --git a/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp b/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
index aa1933cc6..dad1868be 100644
--- a/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
+++ b/test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
@@ -25,4 +25,6 @@
 #endif
 #endif
 
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
diff --git a/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp b/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
index e3030995d..641621e73 100644
--- a/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
+++ b/test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
@@ -23,6 +23,8 @@ using namespace std::filesystem;
 // expected-error@-5 {{expected namespace name}}
 #endif
 
-int main() {
+int main(int, char**) {
 
+
+  return 0;
 }
diff --git a/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp b/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
index 96ba646ff..658643369 100644
--- a/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
+++ b/test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
@@ -17,9 +17,11 @@
 
 using namespace std::filesystem;
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_same<
           path,
           std::filesystem::path
       >::value, "");
+
+  return 0;
 }
diff --git a/test/std/input.output/input.output.general/nothing_to_do.pass.cpp b/test/std/input.output/input.output.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/input.output.general/nothing_to_do.pass.cpp
+++ b/test/std/input.output/input.output.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp b/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
index 0a68da1c4..cb1f2c68e 100644
--- a/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
@@ -38,7 +38,7 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  -$1,234,567.89");
@@ -72,4 +72,6 @@ int main()
         is >> std::get_money(x, true);
         assert(x == -123456789);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp b/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
index 05ed05c39..ebf62c08e 100644
--- a/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
@@ -38,7 +38,7 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  Sat Dec 31 23:55:59 2061");
@@ -72,4 +72,6 @@ int main()
         assert(is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
index 0dffdfb5f..d924d77bc 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
@@ -50,7 +50,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -88,4 +88,6 @@ int main()
         os << std::put_money(x, true);
         assert(sb.str() == L"-USD 1,234,567.89");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
index 7dcbcf488..faa99e063 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
@@ -50,7 +50,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -83,4 +83,6 @@ int main()
         os << std::put_time(&t, L"%a %b %d %H:%M:%S %Y");
         assert(sb.str() == L"Sat Dec 31 23:55:59 2061");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
index b9505c76e..44b394b8f 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
@@ -33,7 +33,7 @@ struct test_iostream
     void swap(test_iostream& s) {base::swap(s);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -81,4 +81,6 @@ int main()
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
index f53411270..c7918ec8d 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
@@ -38,7 +38,7 @@ struct test_iostream
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -86,4 +86,6 @@ int main()
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
index 2dc91457c..611a7a670 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
@@ -38,7 +38,7 @@ struct test_iostream
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -72,4 +72,6 @@ int main()
         assert(is.precision() == 6);
         assert(is.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
index bf6fe65ba..c12abc0e2 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
@@ -23,7 +23,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -51,4 +51,6 @@ int main()
         assert(is.getloc().name() == "C");
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp b/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
index ef7dcd24e..46d7a16aa 100644
--- a/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
@@ -24,7 +24,7 @@
 #include <istream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_istream<char>, std::basic_iostream<char> >::value), "");
     static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_iostream<char> >::value), "");
@@ -33,4 +33,6 @@ int main()
     static_assert((std::is_same<std::basic_iostream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_iostream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_iostream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
index 570aeaa39..799ec5eae 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
index 6a285556d..9f9872d9e 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
index da93a3baf..c2b937a89 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
index f683bee45..702287be7 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
@@ -41,7 +41,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -76,4 +76,6 @@ int main()
         assert(!is.eof());
         assert( is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
index 0c8eee50d..9f9118cbc 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
index 2fff174cb..bdd30190a 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
index 6529ad333..1612468f4 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
index 3c8a0783f..0893d8cde 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
@@ -44,7 +44,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -97,4 +97,6 @@ int main()
         assert( is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
index bc28ec29b..a0d96c398 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
@@ -41,7 +41,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -76,4 +76,6 @@ int main()
         assert(!is.eof());
         assert( is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
index 8bbb636e6..578cfcf0c 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
index 5635339a8..f1c150d79 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
index 402d3eab0..068d31ac8 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
index cedd6a6c8..9906bbeac 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
@@ -40,7 +40,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
index fadc70943..704c4997d 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
@@ -27,11 +27,13 @@ f(std::basic_ios<CharT>& is)
     return is;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
         is >> f;
         assert(f_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
index 51e0aab1a..cbb606cdc 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
@@ -38,7 +38,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -83,4 +83,6 @@ int main()
         assert(!is.fail());
         assert(c == L'c');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
index 31023cca8..ec25dc5a7 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
@@ -25,11 +25,13 @@ f(std::ios_base& is)
     return is;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
         is >> f;
         assert(f_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
index 36ea25daf..f3829c25a 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
@@ -27,11 +27,13 @@ f(std::basic_istream<CharT>& is)
     return is;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
         is >> f;
         assert(f_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
index 293cd8b45..bd06de6a0 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
@@ -38,7 +38,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -66,4 +66,6 @@ int main()
         assert(!is.fail());
         assert(c == 'c');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
index 55db22bce..d5128339a 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
@@ -38,7 +38,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   abcdefghijk    ");
@@ -103,4 +103,6 @@ int main()
         assert(std::string((char*)s) == "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
index dbc6e2398..9feb82690 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
@@ -55,7 +55,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("testing...");
@@ -65,4 +65,6 @@ int main()
         assert(sb2.str() == "testing...");
         assert(is.gcount() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
index 17aff9fd8..3eceaaeb6 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
@@ -38,7 +38,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -66,4 +66,6 @@ int main()
         assert(!is.fail());
         assert(c == 'c');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
index 1873d70fb..14b299314 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
@@ -38,7 +38,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   abcdefghijk    ");
@@ -103,4 +103,6 @@ int main()
         assert(std::string((char*)s) == "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
index cc06149b3..f0a9e0710 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
@@ -38,7 +38,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   abcdefghijk    ");
@@ -114,4 +114,6 @@ int main()
         assert(std::string(s) == "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
index a1ab81a95..6786ebf4c 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
@@ -39,7 +39,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   123");
@@ -75,4 +75,6 @@ int main()
         assert(is.eof());
         assert(is.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
index cd46b14fd..8d0af7347 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
@@ -47,7 +47,7 @@ struct A{};
 bool called = false;
 void operator>>(std::istream&, A&&){ called = true; }
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   123");
@@ -68,4 +68,6 @@ int main()
         assert(&out == &ss);
         assert(called);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
index b73a2fe72..40a041741 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
@@ -37,7 +37,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -96,4 +96,6 @@ int main()
         assert(c == L'c');
         assert(is.gcount() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
index 86189b260..ae31c9be0 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
@@ -37,7 +37,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -99,4 +99,6 @@ int main()
         assert(c == L'c');
         assert(is.gcount() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
index ca2827aa0..149392cae 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
@@ -48,7 +48,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  \n    \n ");
@@ -158,4 +158,6 @@ int main()
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
index efaf168d6..e7c96d6a2 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
@@ -48,7 +48,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  *    * ");
@@ -158,4 +158,6 @@ int main()
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
index 35495ef95..dda59d7ff 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
@@ -52,7 +52,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("testing\n...");
@@ -84,4 +84,6 @@ int main()
         assert(!is.fail());
         assert(is.gcount() == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
index 514cd2e7f..a1e46c233 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
@@ -53,7 +53,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("testing*...");
@@ -85,4 +85,6 @@ int main()
         assert(!is.fail());
         assert(is.gcount() == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
index 5fa822cd1..9c91053eb 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
@@ -48,7 +48,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  \n    \n ");
@@ -142,4 +142,6 @@ int main()
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
index 1cd19c0e1..bee1976e9 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
@@ -48,7 +48,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  *    * ");
@@ -142,4 +142,6 @@ int main()
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
index 99f35aac4..7f6348b01 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
@@ -38,7 +38,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 1\n2345\n6");
@@ -72,4 +72,6 @@ int main()
         assert(!is.fail());
         assert(is.gcount() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
index f2f895d9c..acf90e560 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int bad=-1;
     std::ostringstream os;
@@ -30,4 +30,6 @@ int main()
     is.ignore(ignoreLen);
     std::istringstream::pos_type b=is.tellg();
     assert((b-a)==ignoreLen);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
index 99b2b6934..17943463e 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
@@ -37,7 +37,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 1\n2345\n6");
@@ -65,4 +65,6 @@ int main()
         assert(!is.fail());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
index 2088e4d14..4ca3a8c0e 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
@@ -37,7 +37,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -85,4 +85,6 @@ int main()
         assert(is.bad());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
index 962aa8c03..9296e0bfb 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
@@ -37,7 +37,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -77,4 +77,6 @@ int main()
         assert( is.fail());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
index 5cfd028cc..f99752cc1 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
@@ -37,7 +37,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 1234567890");
@@ -81,4 +81,6 @@ int main()
         assert(std::wstring(s, 1) == L"0");
         assert(is.readsome(s, 5) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
index b5e1955a7..c16a63978 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
@@ -44,7 +44,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -71,4 +71,6 @@ int main()
         assert(is.good());
         assert(!is.eof());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
index d7607b62e..93a7f1912 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
@@ -52,7 +52,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -83,4 +83,6 @@ int main()
         assert(is.good());
         assert(!is.eof());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
index 10bc991aa..43ddd8110 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
@@ -46,7 +46,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -60,4 +60,6 @@ int main()
         assert(is.sync() == 0);
         assert(sync_called == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
index 7f87cada9..918685b86 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
@@ -47,7 +47,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -59,4 +59,6 @@ int main()
         std::wistream is(&sb);
         assert(is.tellg() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
index c982f79cb..ca00af4e3 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
@@ -37,7 +37,7 @@ public:
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -77,4 +77,6 @@ int main()
         assert(is.bad());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
index 8e8b16600..dbb2bb69e 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
@@ -33,7 +33,7 @@ struct test_istream
     void swap(test_istream& s) {base::swap(s);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -81,4 +81,6 @@ int main()
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
index cc418fd4f..455edbf72 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
@@ -38,7 +38,7 @@ struct test_istream
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -86,4 +86,6 @@ int main()
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
index c26ad292b..017cc67a1 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
@@ -48,7 +48,9 @@ struct test_istream
 };
 
 
-int main()
+int main(int, char**)
 {
 
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
index 7bf3d6619..4830d04d4 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
@@ -36,7 +36,7 @@ struct test_istream
         : base(std::move(s)) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -70,4 +70,6 @@ int main()
         assert(is.precision() == 6);
         assert(is.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
index 71008f7d0..339489dfb 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
@@ -23,7 +23,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -51,4 +51,6 @@ int main()
         assert(is.getloc().name() == "C");
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
index 29fed345a..fdebd66fb 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
@@ -49,7 +49,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((testbuf<char>*)0);
@@ -124,4 +124,6 @@ int main()
         assert(sync_called == 0);
         assert(sb.gptr() == sb.eback());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
index 07e2f5558..a5362d94b 100644
--- a/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <istream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ios<char>, std::basic_istream<char> >::value), "");
     static_assert((std::is_same<std::basic_istream<char>::char_type, char>::value), "");
@@ -31,4 +31,6 @@ int main()
     static_assert((std::is_same<std::basic_istream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_istream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_istream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostream.format/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
index f322a8145..433d78ead 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
@@ -33,7 +33,7 @@ struct test_ostream
     void swap(test_ostream& s) {base::swap(s);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -81,4 +81,6 @@ int main()
         assert(os2.precision() == 6);
         assert(os2.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
index a121cd8a5..4241b02a3 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
@@ -38,7 +38,7 @@ struct test_ostream
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -86,4 +86,6 @@ int main()
         assert(os2.precision() == 6);
         assert(os2.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
index 155889de7..811b7fa85 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
@@ -38,7 +38,7 @@ struct test_ostream
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -68,4 +68,6 @@ int main()
         assert(os.precision() == 6);
         assert(os.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
index ea4542be2..78a3a53c7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
@@ -23,7 +23,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -49,4 +49,6 @@ int main()
         assert(os.precision() == 6);
         assert(os.getloc().name() == "C");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
index e472c6266..a0622b365 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -87,4 +87,6 @@ int main()
         os << b;
         assert(sb.str() == "false");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
index f18d9361a..2c83723cb 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "-10.5");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
index 041195d0e..851086abe 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "-10.5");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
index 4657c98f9..7dae78f9d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fffffff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
index cf0184997..8f2ec631c 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fffffff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
index cedef6121..b0c9950bd 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "-10.5");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
index 20b23b80b..d87096f72 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fffffffffffffff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
index c101b3cfc..6db1b55cc 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
@@ -45,7 +45,7 @@ static void test(std::ios_base::fmtflags fmt, const char *expected)
     assert(ss.str() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     const std::ios_base::fmtflags o = std::ios_base::oct;
     const std::ios_base::fmtflags d = std::ios_base::dec;
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
index 7d51a4ddd..c2b188a15 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
@@ -58,7 +58,7 @@ void test_hex(const char *expected)
     assert(str == expected);
 }
 
-int main()
+int main(int, char**)
 {
 
     test_octal<uint16_t>(                "177777");
@@ -110,4 +110,6 @@ int main()
         test_hex<unsigned long long>("FFFFFFFFFFFFFFFF");
         test_hex<         long long>("FFFFFFFFFFFFFFFF");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
index 837efd6f3..f400f3354 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -87,4 +87,6 @@ int main()
         os << n;
         assert(os.good());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
index 8e022edad..c45d5797b 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
index 2d6b0be02..c24381923 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
index 636c87146..03b639643 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fffffff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
index 44313251e..3c12f1488 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fffffffffffffff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
index 16b33f3a9..6cc4c71a0 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@ int main()
         os << n;
         assert(sb.str() == "fff6");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
index cb7f0d62f..127c0c7dc 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == L"a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
index a07edba5d..85edde06d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == L"123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
index 6e926d10f..5532a6865 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == "a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
index 23874768f..f6e2445fa 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == "123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
index f5647e1a9..f12478e53 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == L"a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
index ff4e85eb9..1b11d8550 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == L"123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
index ab3e9b580..26f295ec2 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == "a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
index 36b9586b8..83143521b 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == "123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
index 95609a264..e45281f86 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == "a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
index ef7e6166e..55b429b2d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@ int main()
         assert(sb.str() == "123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
index 1d2056250..921311f99 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
@@ -57,7 +57,7 @@ f(std::basic_ios<CharT>& os)
     return os;
 }
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -66,4 +66,6 @@ int main()
         os << f;
         assert( (os.flags() & std::ios_base::uppercase));
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
index 763be3a83..b10330b7c 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -57,4 +57,6 @@ int main()
         os << std::uppercase;
         assert( (os.flags() & std::ios_base::uppercase));
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
index ab39c28aa..e57e5412c 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
@@ -57,7 +57,7 @@ f(std::basic_ostream<CharT>& os)
     return os;
 }
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -65,4 +65,6 @@ int main()
         os << f;
         assert(sb.str() == "testing...");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
index 5668185b0..d2935ca73 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
@@ -55,7 +55,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -65,4 +65,6 @@ int main()
         os << &sb2;
         assert(sb.str() == "testing...");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
index c6a7d9218..03cd41129 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
@@ -58,7 +58,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -76,4 +76,6 @@ int main()
         assert(sync_called == 2);
         assert(os.good());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
index 20703864b..5f18aecf9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
@@ -49,7 +49,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -67,4 +67,6 @@ int main()
         assert(sb.str().back() == 0);
         assert(os.good());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
index 8ad82cb3a..666a92532 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
@@ -38,7 +38,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -54,4 +54,6 @@ int main()
         assert(sync_called == 2);
         assert(os.good());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
index 7b7890abd..724593f1a 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
@@ -54,7 +54,7 @@ protected:
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -66,4 +66,6 @@ int main()
         std::wostream(&sb) << L"123";
         assert(sb.str() == L"123");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
index f48ed92b8..7be006f10 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
@@ -36,7 +36,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         seekpos_called = 0;
@@ -64,4 +64,6 @@ int main()
         assert(seekpos_called == 1);
         assert(os.rdstate() == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
index 130528046..dc8e5ed5c 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         seekoff_called = 0;
@@ -66,4 +66,6 @@ int main()
         assert(seekoff_called == 1);
         assert(os.rdstate() == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
index a93032b20..d9361e839 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -50,4 +50,6 @@ int main()
         assert(os.tellp() == 10);
         assert(seekoff_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
index f07af7471..15a3b59ea 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
@@ -38,7 +38,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -50,4 +50,6 @@ int main()
         assert(os.bad());
         assert(sync_called == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
index 4dc251751..79f7d9f9f 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -72,4 +72,6 @@ int main()
         assert(sb.str() == "a");
         assert(os.good());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
index 4b804a501..9ebfdf54b 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
@@ -48,7 +48,7 @@ protected:
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -72,4 +72,6 @@ int main()
         assert(sb.str() == s);
         assert(os.good());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
index dbdb52ee7..e0e9cddde 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <ostream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ios<char>, std::basic_ostream<char> >::value), "");
     static_assert((std::is_same<std::basic_ostream<char>::char_type, char>::value), "");
@@ -31,4 +31,6 @@ int main()
     static_assert((std::is_same<std::basic_ostream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ostream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ostream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
index f7d78537e..c21776a9a 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
@@ -33,7 +33,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -57,4 +57,6 @@ int main()
         assert(bool(s));
         assert(sync_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
index ab67442d7..66ed0acba 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
@@ -35,7 +35,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -75,4 +75,6 @@ int main()
         assert(sync_called == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
index c39c08087..1e54e5657 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
@@ -123,7 +123,7 @@ void test_padding () {
 }
 
 
-int main()
+int main(int, char**)
 {
     both_ways ( "" );   // This is a compilation check
 
@@ -173,8 +173,12 @@ int main()
     assert ( unquote (  "" ) ==  "" ); // nothing there
     assert ( unquote ( L"" ) == L"" ); // nothing there
     test_padding ();
-    }
+    
+    return 0;
+}
 
 #else
-int main() {}
+int main(int, char**) {
+  return 0;
+}
 #endif
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
index d7b33cdf2..4b343013e 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
@@ -30,7 +30,7 @@ void round_trip ( const char *p ) {
 
 
 
-int main()
+int main(int, char**)
 {
     round_trip ( "Hi Mom" );
 }
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
index 257826b7d..b19eea376 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
@@ -36,7 +36,7 @@ void round_trip ( const char *p ) {
 
 
 
-int main()
+int main(int, char**)
 {
     round_trip ( "Hi Mom" );
 }
diff --git a/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp b/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
index 82ef40c9a..637aa4ee3 100644
--- a/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
@@ -22,7 +22,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -52,4 +52,6 @@ int main()
         os << std::resetiosflags(std::ios_base::skipws);
         assert(!(os.flags() & std::ios_base::skipws));
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp b/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
index 83d4960c4..580ae4d24 100644
--- a/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
@@ -22,7 +22,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -72,4 +72,6 @@ int main()
         os << std::setbase(15);
         assert((os.flags() & std::ios_base::basefield) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp b/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
index cc548b37d..4398ff613 100644
--- a/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
@@ -21,7 +21,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -35,4 +35,6 @@ int main()
         os << std::setfill(L'*');
         assert(os.fill() == L'*');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp b/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
index f4bf9e7f4..ccf605ad7 100644
--- a/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
@@ -22,7 +22,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -52,4 +52,6 @@ int main()
         os << std::setiosflags(std::ios_base::oct);
         assert(os.flags() & std::ios_base::oct);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp b/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
index eef401c63..e570faf7c 100644
--- a/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
@@ -22,7 +22,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -48,4 +48,6 @@ int main()
         os << std::setprecision(10);
         assert(os.precision() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.format/std.manip/setw.pass.cpp b/test/std/input.output/iostream.format/std.manip/setw.pass.cpp
index cd5e3f2b3..44aa41e57 100644
--- a/test/std/input.output/iostream.format/std.manip/setw.pass.cpp
+++ b/test/std/input.output/iostream.format/std.manip/setw.pass.cpp
@@ -22,7 +22,7 @@ struct testbuf
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -48,4 +48,6 @@ int main()
         os << std::setw(10);
         assert(os.width() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.forward/iosfwd.pass.cpp b/test/std/input.output/iostream.forward/iosfwd.pass.cpp
index 1caadd1c0..5c60dcca2 100644
--- a/test/std/input.output/iostream.forward/iosfwd.pass.cpp
+++ b/test/std/input.output/iostream.forward/iosfwd.pass.cpp
@@ -17,7 +17,7 @@ template <class Ptr> void test()
     ((void)p); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<std::char_traits<char>*          >();
     test<std::char_traits<wchar_t>*       >();
@@ -119,4 +119,6 @@ int main()
     test<std::fpos<std::mbstate_t>*>();
     test<std::streampos*           >();
     test<std::wstreampos*          >();
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
index 1c046bcf4..ef3cbf676 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
@@ -13,7 +13,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::cerr << "Hello World!\n";
@@ -25,4 +25,6 @@ int main()
 #endif
     assert(std::cerr.flags() & std::ios_base::unitbuf);
 #endif  // 0
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
index cce1f3eaf..d28255043 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
@@ -15,7 +15,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::cout << "Hello World!\n";
@@ -30,4 +30,6 @@ int main()
     assert(std::cin.tie() == &std::cout);
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
index 49fffca42..97e67fddf 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
@@ -12,11 +12,13 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::clog << "Hello World!\n";
 #else
     (void)std::clog;
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp b/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
index d470956e2..44ae08577 100644
--- a/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
+++ b/test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::cout << "Hello World!\n";
@@ -25,4 +25,6 @@ int main()
 #else  // 0
     (void)std::cout;
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
index 516f3b8c9..0af3f5ee7 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
@@ -13,7 +13,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wcerr << L"Hello World!\n";
@@ -25,4 +25,6 @@ int main()
 #endif
     assert(std::wcerr.flags() & std::ios_base::unitbuf);
 #endif  // 0
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
index 862f22034..68c152860 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
@@ -15,7 +15,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wcout << L"Hello World!\n";
@@ -30,4 +30,6 @@ int main()
     assert(std::wcin.tie() == &std::wcout);
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
index a6883b257..ad7e35b51 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
@@ -12,11 +12,13 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wclog << L"Hello World!\n";
 #else
     (void)std::wclog;
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp b/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
index ec5bb50ec..5703c6163 100644
--- a/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
+++ b/test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wcout << L"Hello World!\n";
 #else
     (void)std::wcout;
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
index 9c4d74dcd..3938d7980 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
@@ -15,9 +15,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::fpos<int> f;
     f.state(3);
     assert(f.state() == 3);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
index 1b5856608..30bdabc36 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(5);
@@ -24,4 +24,6 @@ int main()
     assert(q == P(11));
     p += o;
     assert(p == q);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
index ff30e81af..e27c90687 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
@@ -15,9 +15,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(5);
     assert(p == P(5));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
index 405c98899..114e382a7 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(11);
     P q(6);
     std::streamoff o = p - q;
     assert(o == 5);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
index 20ffe33c4..1b1a5f33d 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(5);
     P q(6);
     assert(p == p);
     assert(p != q);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
index 108cffdf9..a8e763f72 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(std::streamoff(7));
     std::streamoff offset(p);
     assert(offset == 7);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
index e6cb51ae1..9d9cd7902 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
@@ -13,11 +13,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::streamoff o(5);
     std::streamsize sz(o);
     assert(sz == 5);
     std::streamoff o2(sz);
     assert(o == o2);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp b/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
index 9991be4f9..b38378b7e 100644
--- a/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(11);
@@ -24,4 +24,6 @@ int main()
     assert(q == P(5));
     p -= o;
     assert(p == q);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
index 1a958b615..da147bd82 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
@@ -25,8 +25,10 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.flags() == (test::skipws | test::dec));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
index 0f49701fb..ed39a5424 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
@@ -25,11 +25,13 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     test::fmtflags f = t.flags(test::hex | test::right);
     assert(f == (test::skipws | test::dec));
     assert(t.flags() == (test::hex | test::right));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
index d22ca2647..f6387c828 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
@@ -25,8 +25,10 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.precision() == 6);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
index ab38ab3d5..475ddc47f 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
@@ -25,11 +25,13 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.precision() == 6);
     std::streamsize p = t.precision(10);
     assert(p == 6);
     assert(t.precision() == 10);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
index da742974d..d8ca9cc82 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
@@ -25,11 +25,13 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     test::fmtflags f = t.setf(test::hex | test::right);
     assert(f == (test::skipws | test::dec));
     assert(t.flags() == (test::skipws | test::dec | test::hex | test::right));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
index 00ce003da..6793ced7f 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
@@ -25,11 +25,13 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     test::fmtflags f = t.setf(test::hex | test::right, test::dec | test::right);
     assert(f == (test::skipws | test::dec));
     assert(t.flags() == (test::skipws | test::right));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
index 49a55cb40..f20acff13 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
@@ -25,10 +25,12 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     t.unsetf(test::dec | test::right);
     assert(t.flags() == test::skipws);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
index d812aa291..fc2601a45 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
@@ -25,8 +25,10 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.width() == 0);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
index 7c9060948..3b389e5fd 100644
--- a/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
@@ -25,11 +25,13 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.width() == 0);
     std::streamsize w = t.width(4);
     assert(w == 0);
     assert(t.width() == 4);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
index 3de42eabc..316d23a52 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
@@ -43,7 +43,7 @@ void f1(std::ios_base::event ev, std::ios_base& stream, int index)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -52,4 +52,6 @@ int main()
     b.register_callback(f1, 4);
     std::locale l = b.imbue(std::locale(LOCALE_en_US_UTF_8));
     assert(f1_called == 3);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
index 12434f5a2..7c78ea566 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
@@ -70,7 +70,7 @@ void f3(std::ios_base::event ev, std::ios_base& stream, int index)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -82,4 +82,6 @@ int main()
     assert(f1_called);
     assert(f2_called);
     assert(f3_called);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
index 821a1f514..06b8d83c7 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
@@ -26,8 +26,10 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.getloc().name() == std::string("C"));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
index 0fa77cb7a..ad8898a17 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
@@ -74,7 +74,7 @@ void f3(std::ios_base::event ev, std::ios_base& stream, int index)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -87,4 +87,6 @@ int main()
     assert(f1_called);
     assert(f2_called);
     assert(f3_called);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
index 467b885ce..84eb18370 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
@@ -29,7 +29,7 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -41,4 +41,6 @@ int main()
         for (int j = 0; j <= i; ++j)
             assert(b.iword(j) == j);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
index 65aca332a..c4594615d 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
@@ -30,7 +30,7 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -42,4 +42,6 @@ int main()
         for (std::intptr_t j = 0; j <= i; ++j)
             assert(b.pword(j) == (void*)j);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
index dd95b2681..2fcaddd6d 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::xalloc() == 0);
     assert(std::ios_base::xalloc() == 1);
     assert(std::ios_base::xalloc() == 2);
     assert(std::ios_base::xalloc() == 3);
     assert(std::ios_base::xalloc() == 4);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
index 8937f2585..cd219971e 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
@@ -13,7 +13,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::ios_base::sync_with_stdio(false));
     assert(!std::ios_base::sync_with_stdio(false));
@@ -23,4 +23,6 @@ int main()
     assert( std::ios_base::sync_with_stdio(false));
     assert(!std::ios_base::sync_with_stdio());
     assert( std::ios_base::sync_with_stdio());
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
index 0fc162599..382aeda4f 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
@@ -17,7 +17,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::string what_arg("io test message");
@@ -37,4 +37,6 @@ int main()
         assert(what_message.find(std::iostream_category().message(static_cast<int>
             (std::io_errc::stream))) != std::string::npos);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
index cc607d945..610e6ad15 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
@@ -17,7 +17,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     // LWG2462 std::ios_base::failure is overspecified
     static_assert((std::is_base_of<std::system_error, std::ios_base::failure>::value), "");
@@ -40,4 +40,6 @@ int main()
         assert(what_message.find(std::iostream_category().message(static_cast<int>
             (std::io_errc::stream))) != std::string::npos);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
index 6a51484f3..2eed477b0 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
@@ -32,7 +32,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::boolalpha);
     assert(std::ios_base::dec);
@@ -77,4 +77,6 @@ int main()
                                       | std::ios_base::hex));
     assert(std::ios_base::floatfield == (std::ios_base::scientific
                                        | std::ios_base::fixed));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
index 64123e5d1..7e982f25f 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
@@ -18,7 +18,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::badbit);
     assert(std::ios_base::eofbit);
@@ -32,4 +32,6 @@ int main()
     );
 
     assert(std::ios_base::goodbit == 0);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
index 88c292955..ab21f96b7 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
@@ -20,7 +20,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::app);
     assert(std::ios_base::ate);
@@ -38,4 +38,6 @@ int main()
         & std::ios_base::out
         & std::ios_base::trunc) == 0
     );
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
index 3d0c80974..dfa955c7f 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
@@ -17,9 +17,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::beg != std::ios_base::cur);
     assert(std::ios_base::beg != std::ios_base::end);
     assert(std::ios_base::cur != std::ios_base::end);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
index 8e23732f0..c4eff25bc 100644
--- a/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
@@ -10,6 +10,8 @@
 
 #include <ios>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
index 1bd33e961..01c0d4679 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <streambuf>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::streambuf* sb = 0;
@@ -44,4 +44,6 @@ int main()
         assert(ios.fill() == ' ');
         assert(ios.getloc() == std::locale());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
index 08d00c1c0..949c87e0b 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
@@ -110,7 +110,7 @@ void g3(std::ios_base::event ev, std::ios_base& stream, int index)
     }
 }
 
-int main()
+int main(int, char**)
 {
     testbuf sb1;
     std::ios ios1(&sb1);
@@ -190,4 +190,6 @@ int main()
     assert(ios1.tie() == (std::ostream*)2);
     assert(ios1.fill() == '2');
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
index b5cc96c33..f45c6c8b2 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
@@ -15,8 +15,10 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::ios ios(0);
     assert(ios.fill() == ' ');
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
index b1c56ed53..1c42a03fb 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(ios.fill() == ' ');
     char c = ios.fill('*');
     assert(c == ' ');
     assert(ios.fill() == '*');
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
index 387437290..ed0df788d 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
@@ -68,7 +68,7 @@ void f3(std::ios_base::event ev, std::ios_base& stream, int index)
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -99,4 +99,6 @@ int main()
         assert(f2_called);
         assert(f3_called);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
index 4c6075674..5f99f3db0 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
@@ -77,7 +77,7 @@ void g3(std::ios_base::event ev, std::ios_base&, int index)
     }
 }
 
-int main()
+int main(int, char**)
 {
     testios ios1;
     testbuf sb2;
@@ -136,4 +136,6 @@ int main()
 
     assert(ios2.rdbuf() == &sb2);
     assert(ios2.tie() == 0);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
index b1ffc1e96..afab4ec5d 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
@@ -15,9 +15,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::wios ios(0);
     assert(ios.narrow(L'c', '*') == 'c');
     assert(ios.narrow(L'\u203C', '*') == '*');
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
index bc5871f92..f104cada6 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <streambuf>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::ios ios(0);
@@ -27,4 +27,6 @@ int main()
         const std::ios ios(sb);
         assert(ios.rdbuf() == sb);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
index c1aa1aaf3..5c4e24a82 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <streambuf>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(ios.rdbuf() == 0);
@@ -30,4 +30,6 @@ int main()
     assert(sb2 == (std::streambuf*)1);
     assert(ios.rdbuf() == 0);
     assert(ios.bad());
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
index 65f66cb4b..04b1b9ff6 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
@@ -30,7 +30,7 @@ struct testios
     void set_rdbuf(std::streambuf* x) {std::ios::set_rdbuf(x);}
 };
 
-int main()
+int main(int, char**)
 {
     testbuf sb1;
     testbuf sb2;
@@ -60,4 +60,6 @@ int main()
 #endif
     ios.set_rdbuf(0);
     assert(ios.rdbuf() == 0);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
index 559768b94..40e95bae7 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
@@ -70,7 +70,7 @@ void g3(std::ios_base::event, std::ios_base&, int index)
     g3_called = true;
 }
 
-int main()
+int main(int, char**)
 {
     testbuf sb1;
     testios ios1(&sb1);
@@ -164,4 +164,6 @@ int main()
     ios2.imbue(std::locale("C"));
     assert(f1_called);
     assert(f2_called);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
index 6ea816d7d..c0d7ac173 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
@@ -15,8 +15,10 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::basic_ios<char> ios(0);
     assert(ios.tie() == 0);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
index d2bb41c4e..4ce5966ad 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ostream* os = (std::ostream*)1;
     std::ostream* r = ios.tie(os);
     assert(r == 0);
     assert(ios.tie() == os);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp b/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
index a1585cd54..0ae563718 100644
--- a/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
@@ -15,8 +15,10 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::ios ios(0);
     assert(ios.widen('c') == 'c');
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
index 158c953a4..2308cfa92 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -37,4 +37,6 @@ int main()
         ios.setstate(std::ios::badbit);
         assert(ios.bad());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
index 126431ce2..24fcbff39 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(static_cast<bool>(ios) == !ios.fail());
@@ -30,4 +30,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((!std::is_convertible<std::ios, bool>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
index 7938a84cf..6fc38fde9 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
@@ -20,7 +20,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -66,4 +66,6 @@ int main()
         ios.clear(std::ios::eofbit);
         assert(ios.rdstate() == std::ios::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
index bf6566342..bf1d0246d 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -33,4 +33,6 @@ int main()
         ios.setstate(std::ios::eofbit);
         assert(ios.eof());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
index 9a6b3233f..4632e0043 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         const std::ios ios(0);
@@ -29,4 +29,6 @@ int main()
         const std::ios ios(&sb);
         assert(ios.exceptions() == std::ios::goodbit);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
index 1d56d475a..b8b6577b2 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
@@ -20,7 +20,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -48,4 +48,6 @@ int main()
         ios.exceptions(std::ios::badbit);
         assert(ios.exceptions() == std::ios::badbit);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
index a475c3589..3ae215e45 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -37,4 +37,6 @@ int main()
         ios.setstate(std::ios::failbit);
         assert(ios.fail());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
index e4f28bfe3..19c05edce 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -31,4 +31,6 @@ int main()
         ios.setstate(std::ios::eofbit);
         assert(!ios.good());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
index 151c2244e..20ddb35dc 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(!ios == ios.fail());
     ios.setstate(std::ios::failbit);
     assert(!ios == ios.fail());
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
index dde113a91..37886ac83 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(ios.rdstate() == std::ios::badbit);
     ios.setstate(std::ios::failbit);
     assert(ios.rdstate() == (std::ios::failbit | std::ios::badbit));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp b/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
index 830dd448e..ea954bee0 100644
--- a/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
@@ -20,7 +20,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -65,4 +65,6 @@ int main()
         ios.setstate(std::ios::failbit);
         assert(ios.rdstate() == (std::ios::eofbit | std::ios::failbit));
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/ios/types.pass.cpp b/test/std/input.output/iostreams.base/ios/types.pass.cpp
index 58165fc44..b4a4d7c57 100644
--- a/test/std/input.output/iostreams.base/ios/types.pass.cpp
+++ b/test/std/input.output/iostreams.base/ios/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::ios_base, std::basic_ios<char> >::value), "");
     static_assert((std::is_same<std::basic_ios<char>::char_type, char>::value), "");
@@ -29,4 +29,6 @@ int main()
     static_assert((std::is_same<std::basic_ios<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ios<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ios<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp b/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
index c087871ea..76eb83148 100644
--- a/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
+++ b/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_error_code_enum  <std::io_errc>::value, "");
 #if TEST_STD_VER > 14
     static_assert(std::is_error_code_enum_v<std::io_errc>, "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
index a21481398..fba2e71ca 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::internal(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::internal);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
index 1073e2522..f89d6b9e7 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::left(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::left);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
index c391ab8c5..399d3ba51 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::right(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::right);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
index 64351b6b1..98740cdc0 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::dec(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::dec);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
index cab0bc258..39addcdcf 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::hex(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::hex);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
index a4073646c..92b2d4ee7 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::oct(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::oct);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
index 0517481b8..e017c632a 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
@@ -14,9 +14,11 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::iostream_category();
     std::string m1 = e_cat1.name();
     assert(m1 == "iostream");
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
index 745349d14..060b6284c 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
@@ -13,11 +13,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = make_error_code(std::io_errc::stream);
         assert(ec.value() == static_cast<int>(std::io_errc::stream));
         assert(ec.category() == std::iostream_category());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
index ce9f9f020..3970708bf 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
@@ -13,11 +13,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1 = std::make_error_condition(std::io_errc::stream);
         assert(ec1.value() == static_cast<int>(std::io_errc::stream));
         assert(ec1.category() == std::iostream_category());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
index 7f04bbc51..bb8c424a1 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::fixed));
     assert(!(ios.flags() & std::ios::scientific));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
index 8dbb7a1d8..94cbf1a53 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::fixed(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::fixed);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
index 24afef8b8..c24d7f999 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     assert(&r == &ios);
     assert(ios.flags() & std::ios::fixed);
     assert(ios.flags() & std::ios::scientific);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
index d84aa3775..c8a481944 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::scientific(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::scientific);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
index de58c17f0..176267dd6 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::boolalpha(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::boolalpha);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
index f67ddabae..27d61cee7 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     std::ios_base& r = std::noboolalpha(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::boolalpha));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
index bd904ad64..b730afa88 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     std::ios_base& r = std::noshowbase(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::showbase));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
index 97d919801..0d9f33ea5 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     std::ios_base& r = std::noshowpoint(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::showpoint));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
index 24f8bfca0..fa54cd647 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     std::ios_base& r = std::noshowpos(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::showpos));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
index 5d24d3d41..9ee5ea8e6 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     std::ios_base& r = std::noskipws(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::skipws));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
index 61a7dd29e..ce06e12bd 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     std::ios_base& r = std::nounitbuf(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::unitbuf));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
index 923a6ac75..8e0554620 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@ int main()
     std::ios_base& r = std::nouppercase(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::uppercase));
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
index d584d3128..7f1338c5d 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::showbase(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::showbase);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
index 6cfb73633..03cf312d0 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::showpoint(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::showpoint);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
index 06f1dd836..2fb0d6511 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::showpos(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::showpos);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
index b153bc840..2c64cb8df 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::skipws(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::skipws);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
index 22bcf5eb9..6acedc6a5 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::unitbuf(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::unitbuf);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
index cc2a4bc45..e97763fff 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::uppercase(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::uppercase);
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp b/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
index aaa5b871a..20b953d55 100644
--- a/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
+++ b/test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
@@ -13,8 +13,10 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_integral<std::streamoff>::value, "");
     static_assert(std::is_signed<std::streamoff>::value, "");
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp b/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
index 670932324..50fa21e8d 100644
--- a/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
+++ b/test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
@@ -13,8 +13,10 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_integral<std::streamsize>::value, "");
     static_assert(std::is_signed<std::streamsize>::value, "");
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp b/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp b/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
+++ b/test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/nothing_to_do.pass.cpp b/test/std/input.output/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/nothing_to_do.pass.cpp
+++ b/test/std/input.output/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp b/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
index b94714212..285485087 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
@@ -18,7 +18,9 @@
 
 std::streambuf &get();
 
-int main()
+int main(int, char**)
 {
     std::streambuf sb = get(); // expected-error {{calling a protected constructor}}
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
index c29899291..405c72995 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
@@ -49,7 +49,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -82,4 +82,6 @@ int main()
         test<wchar_t> t;
         test<wchar_t> t2 = t;
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
index 76d47f2a2..ec7650ae0 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
@@ -15,7 +15,9 @@
 
 #include <streambuf>
 
-int main()
+int main(int, char**)
 {
     std::basic_streambuf<char> sb;
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
index 9eebf2557..15475d3d6 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
@@ -35,7 +35,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -54,4 +54,6 @@ int main()
         test<wchar_t> t;
         assert(t.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
index 741b71e38..b49fc2094 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
@@ -24,11 +24,13 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubseekoff(0, std::ios_base::beg) == -1);
         assert(t.pubseekoff(0, std::ios_base::beg, std::ios_base::app) == -1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
index 2e14de9d2..1095c9148 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
@@ -24,10 +24,12 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubseekpos(0, std::ios_base::app) == -1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
index fae4dd78f..c0efb1710 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
@@ -23,10 +23,12 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubsetbuf(0, 0) == &t);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
index 8433a9f31..8d7528ee2 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
@@ -23,10 +23,12 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubsync() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
index ed1d43a86..835944fcf 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
@@ -34,7 +34,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -48,4 +48,6 @@ int main()
                LOCALE_en_US_UTF_8);
         assert(t.getloc().name() == LOCALE_fr_FR_UTF_8);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
index ea51ac64d..6d11a8e89 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -48,4 +48,6 @@ int main()
         t.setg(in, in+2, in+5);
         assert(t.in_avail() == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
index 4aa7a8181..4ac2d6fe5 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@ int main()
         assert(t.sbumpc() == 'B');
         assert(uflow_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
index 2a48158fd..8baefb279 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@ int main()
         assert(t.sgetc() == 'A');
         assert(underflow_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
index 59804043c..9088ed846 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
@@ -31,10 +31,12 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(xsgetn_called == 0);
     assert(t.sgetn(0, 0) == 10);
     assert(xsgetn_called == 1);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
index 830f27282..54965bca2 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@ int main()
         assert(t.snextc() == 'C');
         assert(uflow_called == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
index a2546b810..3b63ba3ce 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@ int main()
         assert(t.sputbackc('A') == 'a');
         assert(pbackfail_called == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
index dcdec61a3..07c1600b0 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
@@ -38,7 +38,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@ int main()
         assert(t.sungetc() == 'a');
         assert(pbackfail_called == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
index 3d04924b1..989b61d4e 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
@@ -42,7 +42,7 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -59,4 +59,6 @@ int main()
         assert(out[0] == 'A');
         assert(out[1] == 'B');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
index bb865636c..01bd9d487 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
@@ -31,10 +31,12 @@ protected:
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(xsputn_called == 0);
     assert(t.sputn(0, 0) == 5);
     assert(xsputn_called == 1);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
index 0c1cd4efb..6109a6aa4 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
@@ -50,7 +50,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -89,4 +89,6 @@ int main()
         test<wchar_t> t2;
         t2 = t;
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
index 6ece9aa57..2809d6312 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
@@ -59,7 +59,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -98,4 +98,6 @@ int main()
         test<wchar_t> t2;
         t2.swap(t);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
index 015a7daa2..161461dee 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
@@ -41,7 +41,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -55,4 +55,6 @@ int main()
         t.setg(in, in+1, in+sizeof(in)/sizeof(in[0]));
         t.gbump(3);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
index 74152974c..b303465f0 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
@@ -33,7 +33,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -45,4 +45,6 @@ int main()
         wchar_t in[] = L"ABC";
         t.setg(in, in+1, in+sizeof(in)/sizeof(in[0]));
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
index 92b869d31..e151d3227 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
@@ -41,7 +41,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -57,4 +57,6 @@ int main()
         t.pbump(3);
         t.pbump(1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
index 5811c9019..eee48f3df 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
@@ -26,7 +26,7 @@ struct SB : std::stringbuf
   const char* pubpptr() const { return pptr(); }
 };
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try {
@@ -40,4 +40,6 @@ int main()
     catch (const std::length_error &) {} // maybe the string can't take 2GB
     catch (const std::bad_alloc    &) {} // maybe we don't have enough RAM
 #endif
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
index 12f955360..6ca36227b 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
@@ -33,7 +33,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -45,4 +45,6 @@ int main()
         wchar_t in[] = L"ABC";
         t.setp(in, in+sizeof(in)/sizeof(in[0]));
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
index b31408e95..5a238e884 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
@@ -25,8 +25,10 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test<char> t;
     assert(t.in_avail() == 0);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
index 1d1ee519f..2f86c3b1a 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
@@ -25,8 +25,10 @@ struct test
 
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sgetc() == -1);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
index 2422c52e5..1d2ce7c5c 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
@@ -22,8 +22,10 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sgetc() == -1);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
index 7c5f6b9d6..f5a95821b 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
@@ -30,7 +30,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     char input[7] = "123456";
@@ -38,4 +38,6 @@ int main()
     char output[sizeof(input)] = {0};
     assert(t.sgetn(output, 10) == 7);
     assert(std::strcmp(input, output) == 0);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
index 1f243e958..217ff8c32 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
@@ -24,8 +24,10 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sputbackc('A') == -1);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
index ae52b9539..e067088f5 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
@@ -22,8 +22,10 @@ struct test
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sputc('A') == -1);
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
index 15d374041..1c30c8f28 100644
--- a/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
@@ -30,7 +30,7 @@ struct test
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -41,4 +41,6 @@ int main()
         assert(t.sputn(in, sizeof(in)) == sizeof(in));
         assert(std::strcmp(in, out) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/stream.buffers/streambuf/types.pass.cpp b/test/std/input.output/stream.buffers/streambuf/types.pass.cpp
index d6ea963df..434f8e3ec 100644
--- a/test/std/input.output/stream.buffers/streambuf/types.pass.cpp
+++ b/test/std/input.output/stream.buffers/streambuf/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <streambuf>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::streambuf::char_type, char>::value), "");
     static_assert((std::is_same<std::streambuf::traits_type, std::char_traits<char> >::value), "");
@@ -35,4 +35,6 @@ int main()
     static_assert((std::is_same<std::wstreambuf::int_type, std::char_traits<wchar_t>::int_type>::value), "");
     static_assert((std::is_same<std::wstreambuf::pos_type, std::char_traits<wchar_t>::pos_type>::value), "");
     static_assert((std::is_same<std::wstreambuf::off_type, std::char_traits<wchar_t>::off_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
index cb4644aad..d0a5863ed 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -52,4 +52,6 @@ int main()
         ss0 >> i;
         assert(i == 321);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
index b906db8d5..567795943 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -82,4 +82,6 @@ int main()
         s1 >> s;
         assert(s == L"Dddddddddddddddddd");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
index 09b6e4b39..b8b00310d 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
@@ -19,7 +19,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -55,4 +55,6 @@ int main()
         ss0 >> i;
         assert(i == 321);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
index 327c4ca12..414c22695 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss;
@@ -42,4 +42,6 @@ int main()
         assert(ss.good());
         assert(ss.str() == L"");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
index c5b144b09..27eb5a745 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -44,4 +44,6 @@ int main()
         ss >> i;
         assert(i == 456);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
index cf3c7d891..04733d604 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss(" 123 456");
@@ -63,4 +63,6 @@ int main()
         ss >> i;
         assert(i == 456);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp b/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
index 9b706a535..4c010e2b4 100644
--- a/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss(" 123 456");
@@ -52,4 +52,6 @@ int main()
         ss >> i;
         assert(i == 789);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/istringstream/types.pass.cpp b/test/std/input.output/string.streams/istringstream/types.pass.cpp
index 0f256cbbd..973196442 100644
--- a/test/std/input.output/string.streams/istringstream/types.pass.cpp
+++ b/test/std/input.output/string.streams/istringstream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_istream<char>, std::basic_istringstream<char> >::value), "");
     static_assert((std::is_same<std::basic_istringstream<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@ int main()
     static_assert((std::is_same<std::basic_istringstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_istringstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_istringstream<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
index af5622ee2..01cc58ae6 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -44,4 +44,6 @@ int main()
         ss0 << i << ' ' << 567;
         assert(ss0.str() == L"234 567");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
index f44b0fba4..bad3c7316 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -42,4 +42,6 @@ int main()
         ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
index 0793fd295..d251e6e08 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -44,4 +44,6 @@ int main()
         ss0 << i << ' ' << 567;
         assert(ss0.str() == L"234 567");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
index 79e0f614c..f772a9040 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss;
@@ -42,4 +42,6 @@ int main()
         assert(ss.good());
         assert(ss.str() == L"");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
index 569310174..3b562bafd 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -40,4 +40,6 @@ int main()
         ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
index 8d64dd5e5..98782dce1 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss(" 123 456");
@@ -55,4 +55,6 @@ int main()
         ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp b/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
index d74acf3a5..56a85159c 100644
--- a/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss(" 123 456");
@@ -48,4 +48,6 @@ int main()
         ss << L"abc";
         assert(ss.str() == L"abc9");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/ostringstream/types.pass.cpp b/test/std/input.output/string.streams/ostringstream/types.pass.cpp
index 15e7dc61f..0da5f98d4 100644
--- a/test/std/input.output/string.streams/ostringstream/types.pass.cpp
+++ b/test/std/input.output/string.streams/ostringstream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_ostringstream<char> >::value), "");
     static_assert((std::is_same<std::basic_ostringstream<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@ int main()
     static_assert((std::is_same<std::basic_ostringstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ostringstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_ostringstream<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
index b5dce8fb9..6977d3189 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -60,4 +60,6 @@ int main()
         assert(buf.str() == L"testing");
         assert(buf1.str() == L"");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
index 2a469ebb7..653edc0d1 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -54,4 +54,6 @@ int main()
         buf = move(buf1);
         assert(buf.str() == L"testing");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
index 5a57f902a..38562fc32 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -62,4 +62,6 @@ int main()
         assert(buf.str() == L"testing");
         assert(buf1.str() == L"");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
index 2121a7a84..836509f2f 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
@@ -31,7 +31,7 @@ struct testbuf
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf;
@@ -49,4 +49,6 @@ int main()
         testbuf<wchar_t> buf;
         buf.check();
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
index 70eff7384..a3cccd39c 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -48,4 +48,6 @@ int main()
         std::wstringbuf buf(move(buf1));
         assert(buf.str() == L"testing");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
index 607d31425..de211c80e 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf("testing");
@@ -43,4 +43,6 @@ int main()
         std::wstringbuf buf(L"testing", std::ios_base::out);
         assert(buf.str() == L"testing");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
index baf406b69..78b572454 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf("testing");
@@ -30,4 +30,6 @@ int main()
         buf.str(L"another test");
         assert(buf.str() == L"another test");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
index 0f8330705..c9fdd0abc 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
@@ -34,7 +34,7 @@ struct testbuf
     void pbump(int n) {base::pbump(n);}
 };
 
-int main()
+int main(int, char**)
 {
     {  // sanity check
     testbuf<char> tb("");
@@ -97,4 +97,6 @@ int main()
         assert(sb.sputc('2') == '2');
         assert(sb.str() == "abc12");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
index dfbe2084b..458e393c8 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
@@ -32,7 +32,7 @@ struct testbuf
     void pbump(int n) {base::pbump(n);}
 };
 
-int main()
+int main(int, char**)
 {
     {  // sanity check
     testbuf<char> tb("");
@@ -92,4 +92,6 @@ int main()
         assert(sb.pbackfail(std::char_traits<wchar_t>::eof()) == std::char_traits<wchar_t>::eof());
         assert(sb.str() == L"133");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
index dbe117eaa..1bee5c216 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf sb(std::ios_base::in);
@@ -163,4 +163,6 @@ int main()
         assert(sb.sputc(L'c') == L'c');
         assert(sb.str() == L"0123456c89");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
index 7d687e070..fde91e74b 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf sb("0123456789", std::ios_base::in);
@@ -73,4 +73,6 @@ int main()
         assert(sb.sputc(L'3') == L'3');
         assert(sb.str() == L"0123456789");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
index 99bc75e6c..f833debe3 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf sb("0123456789");
@@ -28,4 +28,6 @@ int main()
         assert(sb.pubsetbuf(0, 0) == &sb);
         assert(sb.str() == L"0123456789");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
index c32449857..23b77d229 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
@@ -28,7 +28,7 @@ struct testbuf
     void pbump(int n) {base::pbump(n);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("123");
@@ -66,4 +66,6 @@ int main()
         assert(sb.underflow() == L'4');
         assert(sb.underflow() == L'4');
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringbuf/types.pass.cpp b/test/std/input.output/string.streams/stringbuf/types.pass.cpp
index 29d651fc5..c27db8535 100644
--- a/test/std/input.output/string.streams/stringbuf/types.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_streambuf<char>, std::basic_stringbuf<char> >::value), "");
     static_assert((std::is_same<std::basic_stringbuf<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@ int main()
     static_assert((std::is_same<std::basic_stringbuf<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_stringbuf<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_stringbuf<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
index 571c3dc65..11cf288fc 100644
--- a/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss;
@@ -42,4 +42,6 @@ int main()
         assert(ss.good());
         assert(ss.str() == L"");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
index 671aee553..2a73ad9c2 100644
--- a/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -48,4 +48,6 @@ int main()
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
index 4527cae33..044e62824 100644
--- a/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     std::vector<std::istringstream> vecis;
     vecis.push_back(std::istringstream());
@@ -34,4 +34,6 @@ int main()
         vecis[n].seekg(0, std::ios_base::beg);
         assert(vecis[n].str().size() == 31);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
index 7bc383f9a..29c81b3be 100644
--- a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
@@ -27,7 +27,7 @@ struct NoDefaultAllocator : std::allocator<T>
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss(" 123 456 ");
@@ -64,4 +64,6 @@ int main()
     //  This test is not required by the standard, but *where else* could it get the allocator?
         assert(sb.str().get_allocator() == s.get_allocator());
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
index 07d3a1dea..2e0f4471a 100644
--- a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -52,4 +52,6 @@ int main()
         ss0 << i << ' ' << 123;
         assert(ss0.str() == L"456 123");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
index 0332924a6..c3088679e 100644
--- a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -50,4 +50,6 @@ int main()
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
index 3225b273e..06a95dcb3 100644
--- a/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
@@ -19,7 +19,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -55,4 +55,6 @@ int main()
         ss0 << i << ' ' << 123;
         assert(ss0.str() == L"456 123");
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream.members/str.pass.cpp b/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
index 392a1680e..1dc655193 100644
--- a/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss(" 123 456 ");
@@ -63,4 +63,6 @@ int main()
         ss.write("\xd1", 1);
         assert(ss.str().length() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/input.output/string.streams/stringstream/types.pass.cpp b/test/std/input.output/string.streams/stringstream/types.pass.cpp
index e05048a2d..580ccb9a4 100644
--- a/test/std/input.output/string.streams/stringstream/types.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_iostream<char>, std::basic_stringstream<char> >::value), "");
     static_assert((std::is_same<std::basic_stringstream<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@ int main()
     static_assert((std::is_same<std::basic_stringstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_stringstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_stringstream<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.container/data.pass.cpp b/test/std/iterators/iterator.container/data.pass.cpp
index ab80c1cf5..952dc6870 100644
--- a/test/std/iterators/iterator.container/data.pass.cpp
+++ b/test/std/iterators/iterator.container/data.pass.cpp
@@ -61,7 +61,7 @@ void test_const_array( const T (&array)[Sz] )
     assert ( std::data(array) == &array[0]);
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v; v.push_back(1);
     std::array<int, 1> a; a[0] = 3;
@@ -83,4 +83,6 @@ int main()
 
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.container/empty.array.fail.cpp b/test/std/iterators/iterator.container/empty.array.fail.cpp
index 1cd16ad9a..08014776c 100644
--- a/test/std/iterators/iterator.container/empty.array.fail.cpp
+++ b/test/std/iterators/iterator.container/empty.array.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     int c[5];
     std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.container/empty.container.fail.cpp b/test/std/iterators/iterator.container/empty.container.fail.cpp
index 4ac2e1335..153ea13b6 100644
--- a/test/std/iterators/iterator.container/empty.container.fail.cpp
+++ b/test/std/iterators/iterator.container/empty.container.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::vector<int> c;
     std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp b/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
index dcdd89a31..5dafb5119 100644
--- a/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
+++ b/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::initializer_list<int> c = { 4 };
     std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.container/empty.pass.cpp b/test/std/iterators/iterator.container/empty.pass.cpp
index b792e0066..5c46cd6fb 100644
--- a/test/std/iterators/iterator.container/empty.pass.cpp
+++ b/test/std/iterators/iterator.container/empty.pass.cpp
@@ -60,7 +60,7 @@ void test_const_array( const T (&array)[Sz] )
     assert (!std::empty(array));
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v; v.push_back(1);
     std::list<int>   l; l.push_back(2);
@@ -85,4 +85,6 @@ int main()
 
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.container/size.pass.cpp b/test/std/iterators/iterator.container/size.pass.cpp
index 5b78afa26..db215b854 100644
--- a/test/std/iterators/iterator.container/size.pass.cpp
+++ b/test/std/iterators/iterator.container/size.pass.cpp
@@ -63,7 +63,7 @@ void test_const_array( const T (&array)[Sz] )
     assert ( std::size(array) == Sz );
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v; v.push_back(1);
     std::list<int>   l; l.push_back(2);
@@ -87,4 +87,6 @@ int main()
 
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp b/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
index e922a4bfa..b5929ca8c 100644
--- a/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
@@ -72,10 +72,12 @@ test5()
     static_assert((std::is_same<typename It::iterator_category, std::input_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test2<A>();
     test3<A>();
     test4<A>();
     test5<A>();
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
index 6382d06c7..454080563 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
@@ -42,7 +42,7 @@ constepxr_test(It i, typename std::iterator_traits<It>::difference_type n, It x)
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -68,4 +68,6 @@ int main()
     static_assert( constepxr_test(s+5, -5, s), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
index 86fcfbc58..bd1b02a48 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
@@ -37,7 +37,7 @@ constexpr_test(It first, It last, typename std::iterator_traits<It>::difference_
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -57,4 +57,6 @@ int main()
     static_assert( constexpr_test(s, s+10, 10), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
index ad99aed99..87f79fbd3 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
@@ -51,7 +51,7 @@ constexpr_test(It i, It x)
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -83,4 +83,6 @@ int main()
     static_assert( constexpr_test(s, s+1), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
index b7d993917..2ee0444ce 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
@@ -49,7 +49,7 @@ constexpr_test(It i, It x)
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -74,4 +74,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
index 246aeb5e8..5abf59bf3 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<const A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -31,4 +31,6 @@ int main()
     static_assert((std::is_same<It::pointer, const A*>::value), "");
     static_assert((std::is_same<It::reference, const A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
index 774609e1c..358abb619 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
@@ -16,7 +16,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<const volatile A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -24,4 +24,6 @@ int main()
     static_assert((std::is_same<It::pointer, const volatile A*>::value), "");
     static_assert((std::is_same<It::reference, const volatile A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp b/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
index 5c5c07d44..728909e69 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
@@ -63,7 +63,7 @@ struct NotAnIteratorNoCategory
 //     typedef std::forward_iterator_tag iterator_category;
 };
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::iterator_traits<NotAnIteratorEmpty> T;
@@ -118,4 +118,6 @@ int main()
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
index 81dca5186..35fc877f2 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
@@ -30,8 +30,10 @@ public:
     static const bool value = sizeof(test<T>(0)) == 1;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<not_an_iterator> It;
     static_assert(!(has_value_type<It>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
index 1c8d11eb1..1e4d87c75 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
@@ -32,7 +32,7 @@ struct test_iterator
     typedef std::forward_iterator_tag iterator_category;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<test_iterator> It;
     static_assert((std::is_same<It::difference_type, int>::value), "");
@@ -40,4 +40,6 @@ int main()
     static_assert((std::is_same<It::pointer, A*>::value), "");
     static_assert((std::is_same<It::reference, A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::forward_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
index 3be21c49a..6016f6d40 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -31,4 +31,6 @@ int main()
     static_assert((std::is_same<It::pointer, A*>::value), "");
     static_assert((std::is_same<It::reference, A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
index ebcc30075..035360645 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
@@ -16,7 +16,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<volatile A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -24,4 +24,6 @@ int main()
     static_assert((std::is_same<It::pointer, volatile A*>::value), "");
     static_assert((std::is_same<It::reference, volatile A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp b/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
index 6d7f64b9a..8380fb6b4 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
@@ -13,7 +13,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::bidirectional_iterator_tag tag;
     ((void)tag); // Prevent unused warning
@@ -21,4 +21,6 @@ int main()
                                    std::bidirectional_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::bidirectional_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
index 753f25c66..0afdc3eca 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
@@ -13,7 +13,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::forward_iterator_tag tag;
     ((void)tag); // Prevent unused warning
@@ -21,4 +21,6 @@ int main()
                                    std::forward_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::forward_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
index ac517dd67..26de37448 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
@@ -13,10 +13,12 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::input_iterator_tag tag;
     ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::input_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
index 1635850cf..657e6f8ea 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
@@ -13,10 +13,12 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::output_iterator_tag tag;
     ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::input_iterator_tag,
                                     std::output_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp b/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
index da2de4681..5448a6715 100644
--- a/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
+++ b/test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
@@ -13,7 +13,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::random_access_iterator_tag tag;
     ((void)tag); // Prevent unused warning
@@ -21,4 +21,6 @@ int main()
                                    std::random_access_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.range/begin-end.fail.cpp b/test/std/iterators/iterator.range/begin-end.fail.cpp
index b87b82f27..69a278434 100644
--- a/test/std/iterators/iterator.range/begin-end.fail.cpp
+++ b/test/std/iterators/iterator.range/begin-end.fail.cpp
@@ -40,11 +40,13 @@ namespace Foo {
 }
 
 
-int main(){
+int main(int, char**) {
 // Bug #28927 - shouldn't find these via ADL
     TEST_IGNORE_NODISCARD  std::cbegin (Foo::FakeContainer());
     TEST_IGNORE_NODISCARD  std::cend   (Foo::FakeContainer());
     TEST_IGNORE_NODISCARD  std::crbegin(Foo::FakeContainer());
     TEST_IGNORE_NODISCARD  std::crend  (Foo::FakeContainer());
+
+  return 0;
 }
 #endif
diff --git a/test/std/iterators/iterator.range/begin-end.pass.cpp b/test/std/iterators/iterator.range/begin-end.pass.cpp
index a55e0b639..7580b463d 100644
--- a/test/std/iterators/iterator.range/begin-end.pass.cpp
+++ b/test/std/iterators/iterator.range/begin-end.pass.cpp
@@ -135,7 +135,7 @@ void test_const_array( const T (&array)[Sz] ) {
 #endif
     }
 
-int main(){
+int main(int, char**) {
     std::vector<int> v; v.push_back(1);
     std::list<int> l;   l.push_back(2);
     std::array<int, 1> a; a[0] = 3;
@@ -197,4 +197,6 @@ int main(){
         static_assert ( *std::crbegin(c) == 4, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp b/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp b/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/iterators.general/gcc_workaround.pass.cpp b/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
index a6be18d10..09b4d7628 100644
--- a/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
+++ b/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
@@ -17,4 +17,6 @@ void f(const std::string &s) { TEST_IGNORE_NODISCARD s.begin(); }
 
 void AppendTo(const std::vector<char> &v) { TEST_IGNORE_NODISCARD v.begin(); }
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/iterators/iterators.general/nothing_to_do.pass.cpp b/test/std/iterators/iterators.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/iterators.general/nothing_to_do.pass.cpp
+++ b/test/std/iterators/iterators.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
index 1bdd5ddef..9aad14992 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
@@ -17,7 +17,9 @@
 #include <iterator>
 #include <vector>
 
-int main()
+int main(int, char**)
 {
     std::back_insert_iterator<std::vector<int> > i = std::vector<int>();
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
index 22f16c2eb..2aad3fa3f 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
@@ -23,8 +23,10 @@ test(C c)
     std::back_insert_iterator<C> i(c);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
index ccb22b2bd..d36b1ce06 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
@@ -28,8 +28,10 @@ test(C c)
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
index acb272b4c..512eb1e56 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
@@ -26,8 +26,10 @@ test(C c)
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
index 67772dabc..2b76a2714 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
@@ -39,7 +39,9 @@ public:
         {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::vector<Copyable>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
index 93fe8e5fa..506b7b6f0 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
@@ -31,7 +31,9 @@ test(C c)
     assert(c.back() == typename C::value_type());
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<std::unique_ptr<int> >());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
index b7f11e0f7..460f723a4 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
@@ -26,8 +26,10 @@ test(C c)
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
index 6c27ce826..bd6df6448 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
@@ -27,8 +27,10 @@ test(C c)
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
index 47d384382..470392bc5 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
@@ -52,7 +52,9 @@ test()
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >();
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
index 1ebfd4d3f..eb3346b2e 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
@@ -17,7 +17,9 @@
 #include <iterator>
 #include <list>
 
-int main()
+int main(int, char**)
 {
     std::front_insert_iterator<std::list<int> > i = std::list<int>();
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
index 80307cb15..2ef4ba879 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
@@ -23,8 +23,10 @@ test(C c)
     std::front_insert_iterator<C> i(c);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
index 9b642a7d2..7c9b09ffd 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
@@ -28,8 +28,10 @@ test(C c)
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
index 7aa1d6da6..ea5c02410 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
@@ -26,8 +26,10 @@ test(C c)
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
index 555b72d79..5e1a86d57 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
@@ -39,8 +39,10 @@ public:
         {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::list<Copyable>());
     test(nasty_list<Copyable>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
index ad032a4dd..450f395d4 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
@@ -29,7 +29,9 @@ test(C c)
     assert(c.front() == typename C::value_type());
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<std::unique_ptr<int> >());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
index bf1bf38ad..3367229b4 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
@@ -26,8 +26,10 @@ test(C c)
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
index f4cc7c984..b7436778d 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
@@ -27,8 +27,10 @@ test(C c)
     assert(c.front() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
index c8609efbe..c65a8e6f6 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
@@ -53,7 +53,9 @@ test()
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >();
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
index ae45c90f3..531dac03c 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
@@ -23,8 +23,10 @@ test(C c)
     std::insert_iterator<C> i(c, c.begin());
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
index 22448fddd..a3148e2e2 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
@@ -28,8 +28,10 @@ test(C c)
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
index c9a8d1ef6..99c686095 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
@@ -26,8 +26,10 @@ test(C c)
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
index c639a2da1..fe8260b99 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
@@ -43,7 +43,7 @@ insert3at(C& c, typename C::iterator i,
     c.insert(++i, x3);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> C;
@@ -81,4 +81,6 @@ int main()
     insert3at(c2, c2.begin()+3, 'a', 'b', 'c');
     test(c1, 3, 'a', 'b', 'c', c2);
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
index 671d6bd49..7a5addb1a 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
@@ -52,7 +52,7 @@ struct do_nothing
     void operator()(void*) const {}
 };
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unique_ptr<int, do_nothing> Ptr;
@@ -91,4 +91,6 @@ int main()
     insert3at(c2, c2.begin()+3, Ptr(x+3), Ptr(x+4), Ptr(x+5));
     test(std::move(c1), 3, Ptr(x+3), Ptr(x+4), Ptr(x+5), c2);
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
index d531e5fe3..8ef0383ee 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
@@ -26,8 +26,10 @@ test(C c)
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
index 05ede8a52..e1ee829bc 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
@@ -27,8 +27,10 @@ test(C c)
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
index 9d58fc40c..1e199b305 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
@@ -58,7 +58,9 @@ test()
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >();
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
index 36dfddd7f..3a9b467e0 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
@@ -30,7 +30,7 @@ test(It i)
     assert(std::make_move_iterator(i) == r);
 }
 
-int main()
+int main(int, char**)
 {
     {
     char s[] = "1234567890";
@@ -53,4 +53,6 @@ int main()
     static_assert(iter.base() == p);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
index 678522597..e3b881edc 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
@@ -33,7 +33,7 @@ test(It l, It r, typename std::iterator_traits<It>::difference_type x)
     assert(r1 - r2 == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s+5), random_access_iterator<char*>(s), 5);
@@ -49,4 +49,6 @@ int main()
     static_assert( it2 - it1 ==  1, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
index 63c3e8ed5..5e1965e19 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
@@ -31,7 +31,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s+5), 5, random_access_iterator<char*>(s+10));
@@ -49,4 +49,6 @@ int main()
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
index 95ab190f1..1e3244e19 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
@@ -30,7 +30,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -48,4 +48,6 @@ int main()
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
index 0af1ff83f..863e06c0e 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
@@ -31,7 +31,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -49,4 +49,6 @@ int main()
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
index ce0cb93cf..3cf76f5da 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
@@ -30,7 +30,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -48,4 +48,6 @@ int main()
     static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
index f17543335..5692f7088 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
@@ -31,7 +31,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -45,4 +45,6 @@ int main()
     static_assert(it1 == it2, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
index 1e05a50c7..ecf8f90ea 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 == r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(input_iterator<char*>(s), input_iterator<char*>(s), true);
@@ -58,4 +58,6 @@ int main()
     static_assert(!(it2 == it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
index e58a57b50..3da38b376 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 > r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
@@ -54,4 +54,6 @@ int main()
     static_assert( (it2 > it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
index e10962f02..dceb41151 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 >= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
@@ -54,4 +54,6 @@ int main()
     static_assert( (it2 >= it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
index ebe90244e..675e55f78 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 < r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
@@ -54,4 +54,6 @@ int main()
     static_assert(!(it2 < it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
index 72efc481e..a2ac0b7a6 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 <= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
@@ -54,4 +54,6 @@ int main()
     static_assert(!(it2 <= it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
index 69695e56b..01a7195d4 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 != r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(input_iterator<char*>(s), input_iterator<char*>(s), false);
@@ -58,4 +58,6 @@ int main()
     static_assert( (it2 != it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
index 56b99025e..b91767b08 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
@@ -29,9 +29,11 @@ test(U u)
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
 
     test<base*>(&d);
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
index dae13100d..7f31920f7 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
@@ -34,7 +34,7 @@ test(U u)
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -52,4 +52,6 @@ int main()
     static_assert(it2.base() == p);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
index dfd89df80..6dfa0d09d 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
@@ -27,7 +27,7 @@ test()
     (void)r;
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<char*> >();
     test<forward_iterator<char*> >();
@@ -41,4 +41,6 @@ int main()
     (void)it;
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
index 0b8ea4540..28648b815 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
@@ -23,8 +23,10 @@ test(It i)
     std::move_iterator<It> r = i;
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(s);
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
index 5832ecbcf..bed97700e 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
@@ -28,7 +28,7 @@ test(It i)
     assert(r.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(input_iterator<char*>(s));
@@ -44,4 +44,6 @@ int main()
     static_assert(it.base() == p);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
index 0b6db37e1..38d523297 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
@@ -49,4 +49,6 @@ int main()
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
index c7c00183c..e98fb6b09 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
@@ -49,4 +49,6 @@ int main()
     static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
index f37522c13..50597a54b 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(input_iterator<char*>(s), input_iterator<char*>(s+1));
@@ -51,4 +51,6 @@ int main()
     static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
index 4bcbdd579..101f5cdbc 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(input_iterator<char*>(s), input_iterator<char*>(s+1));
@@ -51,4 +51,6 @@ int main()
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
index d626ff28a..ecf3b6105 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
@@ -38,7 +38,7 @@ struct do_nothing
     void operator()(void*) const {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         char s[] = "1234567890";
@@ -64,4 +64,6 @@ int main()
     static_assert(it1[5] == '6', "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
index 027162b90..6024f99fe 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
@@ -27,7 +27,7 @@ test(It i)
     assert(r.operator->() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(s);
@@ -42,4 +42,6 @@ int main()
     static_assert(it2.operator->() == p + 1, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
index 6dfe0a517..e6e826d83 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
@@ -47,7 +47,7 @@ struct do_nothing
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         A a;
@@ -70,4 +70,6 @@ int main()
     static_assert(*it2 == p[1], "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
index 68fe476ac..94d012dfb 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
@@ -31,8 +31,10 @@ test(U u)
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
     test<base*>(&d);
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
index fbc5320fe..84fbccb8b 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
@@ -37,7 +37,7 @@ test(U u)
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -56,4 +56,6 @@ int main()
     static_assert(it2.base() == p, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
index 9eb4669c3..905952f42 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -55,7 +55,7 @@ test()
     static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<char*> >();
     test<forward_iterator<char*> >();
@@ -91,4 +91,6 @@ int main()
         static_assert(std::is_same<It::reference, int&&>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
index de035fcd3..32931eefa 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
@@ -27,7 +27,7 @@ test()
     (void)r;
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const char*> >();
     test<random_access_iterator<char*> >();
@@ -40,4 +40,6 @@ int main()
         (void)it;
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
index bbbf1247f..6130386b0 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
@@ -23,8 +23,10 @@ test(It i)
     std::reverse_iterator<It> r = i;
 }
 
-int main()
+int main(int, char**)
 {
     const char s[] = "123";
     test(s);
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
index 47fc29b09..32cc74f95 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
@@ -28,7 +28,7 @@ test(It i)
     assert(r.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char s[] = "123";
     test(bidirectional_iterator<const char*>(s));
@@ -42,4 +42,6 @@ int main()
         static_assert(it.base() == p);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
index 02ab54a59..5a878e493 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
@@ -29,9 +29,11 @@ test(U u)
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
 
     test<base*>(&d);
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
index db53853dc..53b82bd40 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
@@ -34,7 +34,7 @@ test(U u)
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -50,4 +50,6 @@ int main()
         static_assert(it2.base() == p);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
index 8ad3d79b3..fa7026dde 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
@@ -31,7 +31,7 @@ test(It i)
     assert(r.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     random_access_iterator<const char*>b(s);
@@ -46,5 +46,7 @@ int main()
         static_assert(it1.base() == p, "");
     }
 #endif
+
+  return 0;
 }
 
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
index c67884d91..f3e749709 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 != r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), false);
@@ -53,4 +53,6 @@ int main()
         static_assert( (it1 != it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
index 2232a87f5..d7658ccfc 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
@@ -49,4 +49,6 @@ int main()
         static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
index d2337e208..edc74fab5 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
@@ -50,4 +50,6 @@ int main()
         static_assert(*(++std::make_reverse_iterator(p+2)) == '1', "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
index eed06f3df..9b30f59da 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
@@ -30,7 +30,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -48,4 +48,6 @@ int main()
         static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
index 546038213..229f3ca11 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
@@ -31,7 +31,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -45,4 +45,6 @@ int main()
         static_assert(it1 == it2, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
index 35fdf1b1e..8b9912c81 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
@@ -49,4 +49,6 @@ int main()
         static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
index f0df91777..9ccab06e8 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
@@ -30,7 +30,7 @@ test(It i, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
@@ -50,4 +50,6 @@ int main()
         static_assert(*(--std::make_reverse_iterator(p)) == '1', "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
index b59095db8..0e3a5d362 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
@@ -30,7 +30,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -48,4 +48,6 @@ int main()
         static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
index a484a67a7..ab92dc068 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
@@ -31,7 +31,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -45,4 +45,6 @@ int main()
         static_assert(it1 == it2, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
index efe3dbf9c..820ee0060 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
@@ -43,7 +43,7 @@ test(It i, typename std::iterator_traits<It>::value_type x)
     assert(*r == x);
 }
 
-int main()
+int main(int, char**)
 {
     A a;
     test(&a+1, A());
@@ -58,4 +58,6 @@ int main()
         static_assert(*it2 == p[1], "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
index 0580eb098..071e3ef10 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
@@ -31,8 +31,10 @@ test(U u)
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
     test<base*>(&d);
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
index e39476a98..838bdc917 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
@@ -37,7 +37,7 @@ test(U u)
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -55,4 +55,6 @@ int main()
         static_assert(it2.base() == p, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
index 066aa769b..7bd699bb9 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 == r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), true);
@@ -54,4 +54,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
index 2c7574eb4..ce9012348 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
@@ -33,7 +33,7 @@ test(It1 l, It2 r, std::ptrdiff_t x)
     assert((r1 - r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[3] = {0};
     test(random_access_iterator<const char*>(s), random_access_iterator<char*>(s), 0);
@@ -53,4 +53,6 @@ int main()
         static_assert( it2 - it1 == -1, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
index d32932848..86b19e3fc 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 > r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
@@ -53,4 +53,6 @@ int main()
         static_assert( (it1 > it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
index b12f7c135..de5328120 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 >= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
@@ -53,4 +53,6 @@ int main()
         static_assert( (it1 >= it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
index a1b08f65c..bc20d1381 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
@@ -30,7 +30,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n,
     assert(rr == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 4, '1');
@@ -45,4 +45,6 @@ int main()
     static_assert(it1[4] == '1', "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
index 7e4f27e7a..e49821f83 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 < r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
@@ -53,4 +53,6 @@ int main()
         static_assert(!(it1 < it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
index 8934d68ef..927523611 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
@@ -32,7 +32,7 @@ test(It l, It r, bool x)
     assert((r1 <= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
@@ -53,4 +53,6 @@ int main()
         static_assert(!(it1 <= it3), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
index ce0b470a6..f16fb2757 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
@@ -76,7 +76,7 @@ public:
 
 TEST_CONSTEXPR  C gC;
 
-int main()
+int main(int, char**)
 {
     A a;
     test(&a+1, A());
@@ -115,4 +115,6 @@ int main()
     {
         ((void)gC);
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
index 25876d072..ba3844851 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
@@ -31,7 +31,7 @@ test(It i, typename std::iterator_traits<It>::difference_type n, It x)
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -49,4 +49,6 @@ int main()
         static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
index 7242f6a34..11ac62525 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
@@ -52,9 +52,11 @@ test()
     static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<char*> >();
     test<random_access_iterator<char*> >();
     test<char*>();
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
index 4ee68b5fc..d6a3b0862 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istream_iterator<int> io;
@@ -36,4 +36,6 @@ int main()
         j = *i;
         assert(j == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
index 1ffe4dcfe..e2bebbaea 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
@@ -19,7 +19,7 @@
 
 struct S { S(); }; // not constexpr
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -28,4 +28,6 @@ int main()
 #else
 #error "C++11 only test"
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
index f569d3206..fa43566dd 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
@@ -42,7 +42,7 @@ void operator ()() const {}
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::istream_iterator<int> T;
@@ -61,4 +61,6 @@ int main()
     test_trivial<S>()();
     test_trivial<std::string>()();
 #endif
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
index 50b40aba4..a4c47974d 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -26,4 +26,6 @@ int main()
     int j = 0;
     inf >> j;
     assert(j == 23);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
index a2862b403..5409cc595 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
@@ -29,10 +29,12 @@ std::istream& operator>>(std::istream& is, A& a)
     return is >> a.d_ >> a.i_;
 }
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf("1.5  23 ");
     std::istream_iterator<A> i(inf);
     assert(i->d_ == 1.5);
     assert(i->i_ == 23);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
index 38ffe4bfd..c99e723b0 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -30,4 +30,6 @@ int main()
     assert(j == 23);
     j = *i;
     assert(j == 23);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
index 5ba335c5e..616a3ca38 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
@@ -22,7 +22,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf1(" 1 23");
     std::istringstream inf2(" 1 23");
@@ -51,4 +51,6 @@ int main()
 
     assert(std::operator==(i1, i2));
     assert(std::operator!=(i1, i3));
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
index b32f358cf..83d206e71 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -28,4 +28,6 @@ int main()
     j = 0;
     j = *icopy;
     assert(j == 1);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
index 6a361ff71..ab61f57f9 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -25,4 +25,6 @@ int main()
     int j = 0;
     j = *i;
     assert(j == 23);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
index 9a7185c1b..5170b1e53 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
@@ -41,7 +41,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::istream_iterator<double> I1; // double is trivially destructible
 #if TEST_STD_VER <= 14
@@ -82,4 +82,6 @@ int main()
     typedef std::istream_iterator<std::string> I3; // string is NOT trivially destructible
     static_assert(!std::is_trivially_copy_constructible<I3>::value, "");
     static_assert(!std::is_trivially_destructible<I3>::value, "");
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
index d7e1a31e5..9502e0da7 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::istreambuf_iterator<char> T;
@@ -41,4 +41,6 @@ int main()
         (void)it2;
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
index a7927cbb2..b51d19a8e 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf;
@@ -38,4 +38,6 @@ int main()
         std::istreambuf_iterator<wchar_t> i(inf);
         assert(i != std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
index 6b4719cad..87afe840d 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -32,4 +32,6 @@ int main()
         assert(i != std::istreambuf_iterator<wchar_t>());
         assert(*i == L'b');
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
index 2b94d8c97..d92cddde1 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istreambuf_iterator<char> i(nullptr);
@@ -46,4 +46,6 @@ int main()
         std::istreambuf_iterator<wchar_t> i(inf.rdbuf());
         assert(i != std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
index 9b0034131..1fcdf7af1 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf1("abc");
@@ -96,4 +96,6 @@ int main()
         assert( i5.equal(i4));
         assert( i5.equal(i5));
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
index 7e50c68f7..d4184aa6c 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf1("abc");
@@ -98,4 +98,6 @@ int main()
         assert(!(i5 != i4));
         assert(!(i5 != i5));
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
index 28cb7a93a..d60302ad4 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -36,4 +36,6 @@ int main()
         ++i;
         assert(*i == L'c');
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
index ede97380b..875989f5d 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf1("abc");
@@ -98,4 +98,6 @@ int main()
         assert( (i5 == i4));
         assert( (i5 == i5));
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
index 15c266d73..e3121494d 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -34,4 +34,6 @@ int main()
         assert(*i++ == L'c');
         assert(i == std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
index 148bd725a..9d05cbda3 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -35,4 +35,6 @@ int main()
         assert(*++i == L'c');
         assert(++i == std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
index 2535d9913..74e1813d5 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
@@ -28,7 +28,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -40,4 +40,6 @@ int main()
         std::istreambuf_iterator<wchar_t> i(inf);
         assert(*i++ == L'a');
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
index 829d1f0a6..a6c6435f1 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
@@ -34,7 +34,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::istreambuf_iterator<char> I1;
     static_assert((std::is_same<I1::iterator_category, std::input_iterator_tag>::value), "");
@@ -65,4 +65,6 @@ int main()
     static_assert((std::is_nothrow_default_constructible<I2>::value), "" );
     static_assert((std::is_trivially_copy_constructible<I2>::value), "" );
     static_assert((std::is_trivially_destructible<I2>::value), "" );
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
index 3521b05fa..8d7500cf2 100644
--- a/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
@@ -13,11 +13,13 @@
 #include <iterator>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     int* i = std::begin(ia);
     assert(*i == 1);
     *i = 2;
     assert(ia[0] == 2);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
index 255a837e7..06b5e7907 100644
--- a/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
@@ -13,10 +13,12 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     const std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
     std::vector<int>::const_iterator i = begin(v);
     assert(*i == 1);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
index bc99f7a40..75e61d3b4 100644
--- a/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
@@ -21,4 +21,6 @@ int main()
     assert(*i == 1);
     *i = 2;
     assert(*i == 2);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
index 0f21309ba..a6721155a 100644
--- a/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
@@ -13,11 +13,13 @@
 #include <iterator>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     int* i = std::begin(ia);
     int* e = std::end(ia);
     assert(e == ia + 3);
     assert(e - i == 3);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
index 457962332..78a6affd8 100644
--- a/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
@@ -13,10 +13,12 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     const std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
     std::vector<int>::const_iterator i = end(v);
     assert(i == v.cend());
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp b/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
index 8fa2a4e56..9970ec922 100644
--- a/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
+++ b/test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
@@ -13,10 +13,12 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
     std::vector<int>::iterator i = end(v);
     assert(i == v.end());
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp b/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
+++ b/test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
index 24cf15ff1..491f3bc1c 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
@@ -16,11 +16,13 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream outf;
     std::ostream_iterator<int> i(outf);
     std::ostream_iterator<int> j = i;
     assert(outf.good());
     ((void)j);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
index 1de0ea2ea..78abcfab6 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
@@ -23,7 +23,7 @@ typedef std::basic_ostream<char, MyTraits> BasicStream;
 
 void operator&(BasicStream const&) {}
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -35,4 +35,6 @@ int main()
         std::ostream_iterator<int, char, MyTraits> i(outf);
         assert(outf.good());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
index 7b4422f94..2c48189f9 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
@@ -24,7 +24,7 @@ typedef std::basic_ostream<char, MyTraits> BasicStream;
 
 void operator&(BasicStream const&) {}
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -41,4 +41,6 @@ int main()
         std::ostream_iterator<int, char, MyTraits> i(outf, ", ");
         assert(outf.good());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
index dea585c3c..5a2f2cc99 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
@@ -26,7 +26,7 @@
 #pragma warning(disable: 4244) // conversion from 'X' to 'Y', possible loss of data
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -52,4 +52,6 @@ int main()
         i = 2.4;
         assert(outf.str() == L"2, ");
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
index 4d79f7c1d..6cb190ab4 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream os;
     std::ostream_iterator<int> i(os);
     std::ostream_iterator<int>& iref = *i;
     assert(&iref == &i);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
index d93aad6cc..eedab8115 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream os;
     std::ostream_iterator<int> i(os);
@@ -25,4 +25,6 @@ int main()
     assert(&iref1 == &i);
     std::ostream_iterator<int>& iref2 = i++;
     assert(&iref2 == &i);
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
index 716ba2bfd..950c7dfe8 100644
--- a/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::ostream_iterator<double> I1;
 #if TEST_STD_VER <= 14
@@ -54,4 +54,6 @@ int main()
     static_assert((std::is_same<I2::char_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::ostream_type, std::wostream>::value), "");
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
index 0c28a77ac..aa6031a8a 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -28,4 +28,6 @@ int main()
         std::ostreambuf_iterator<wchar_t> i(outf);
         assert(!i.failed());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
index 0d2c85bef..2c64dc29f 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -28,4 +28,6 @@ int main()
         std::ostreambuf_iterator<wchar_t> i(outf.rdbuf());
         assert(!i.failed());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
index 45e57fc80..fe51fba1f 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -35,4 +35,6 @@ int main()
         i = L'b';
         assert(outf.str() == L"ab");
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
index e33a5a5c8..4904320b0 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -30,4 +30,6 @@ int main()
         std::ostreambuf_iterator<wchar_t>& iref = *i;
         assert(&iref == &i);
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
index b52fce813..fa67513ad 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
@@ -25,7 +25,7 @@ struct my_streambuf : public std::basic_streambuf<Char,Traits> {
     int_type sputc(char_type) { return Traits::eof(); }
     };
 
-int main()
+int main(int, char**)
 {
     {
         my_streambuf<char> buf;
@@ -39,4 +39,6 @@ int main()
         i = L'a';
         assert(i.failed());
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
index c765a5c2d..81ae55ae7 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -35,4 +35,6 @@ int main()
         std::ostreambuf_iterator<wchar_t>& iref2 = i++;
         assert(&iref2 == &i);
     }
+
+  return 0;
 }
diff --git a/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp b/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
index 346d8b849..671a09bb7 100644
--- a/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
+++ b/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::ostreambuf_iterator<char> I1;
 #if TEST_STD_VER <= 14
@@ -58,4 +58,6 @@ int main()
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::streambuf_type, std::wstreambuf>::value), "");
     static_assert((std::is_same<I2::ostream_type, std::wostream>::value), "");
+
+  return 0;
 }
diff --git a/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp b/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
index 4c999637f..218291b6b 100644
--- a/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
+++ b/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
@@ -33,7 +33,7 @@ void test_cat() {
 
 // [class.spaceship]p4: The 'common comparison type' U of a possibly-empty list
 //   of 'n' types T0, T1, ..., TN, is defined as follows:
-int main() {
+int main(int, char**) {
   using WE = std::weak_equality;
   using SE = std::strong_equality;
   using PO = std::partial_ordering;
@@ -89,4 +89,6 @@ int main() {
     test_cat<SO, SO>();
     test_cat<SO, SO, SO>();
   }
+
+  return 0;
 }
diff --git a/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp b/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
index 6c51b7a20..f2e673db6 100644
--- a/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
@@ -155,9 +155,11 @@ constexpr bool test_constexpr() {
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
diff --git a/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp b/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
index e34cadc55..a5af910a5 100644
--- a/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
+++ b/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
@@ -87,9 +87,11 @@ constexpr bool test_constexpr() {
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   test_conversion();
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
diff --git a/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp b/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
index 4b75e5d51..a31fd34d4 100644
--- a/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
@@ -203,9 +203,11 @@ constexpr bool test_constexpr() {
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
diff --git a/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp b/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
index dae2f2147..367aac6be 100644
--- a/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
+++ b/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
@@ -62,8 +62,10 @@ constexpr bool test_constexpr() {
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
diff --git a/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp b/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
index 6e9e7d441..ada8d240b 100644
--- a/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
+++ b/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
@@ -160,9 +160,11 @@ constexpr bool test_constexpr() {
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
diff --git a/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp b/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
index 6f46342da..ec4afd7f6 100644
--- a/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
+++ b/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
@@ -18,7 +18,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     // typedef std::int8_t
     static_assert(sizeof(std::int8_t)*CHAR_BIT == 8,
@@ -288,4 +288,6 @@ int main()
 #ifndef UINTMAX_C
 #error UINTMAX_C not defined
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/nothing_to_do.pass.cpp b/test/std/language.support/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/nothing_to_do.pass.cpp
+++ b/test/std/language.support/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/align_val_t.pass.cpp b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
index 1b0b4c00b..6e6551823 100644
--- a/test/std/language.support/support.dynamic/align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
@@ -14,7 +14,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     static_assert(std::is_enum<std::align_val_t>::value, "");
     static_assert(std::is_same<std::underlying_type<std::align_val_t>::type, std::size_t>::value, "");
@@ -30,4 +30,6 @@ int main() {
     static_assert(b == std::align_val_t(32), "");
     static_assert(static_cast<std::size_t>(c) == (std::size_t)-1, "");
   }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
index 713e66245..f0b2bd21f 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_alloc>::value),
                  "std::is_base_of<std::exception, std::bad_alloc>::value");
@@ -23,4 +23,6 @@ int main()
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
index d2fefdd1b..35fd13041 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::bad_alloc, std::bad_array_new_length>::value),
                   "std::is_base_of<std::bad_alloc, std::bad_array_new_length>::value");
@@ -23,4 +23,6 @@ int main()
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
index f5681d8d9..b69fe1523 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
@@ -14,9 +14,11 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::new_handler, void(*)()>::value), "");
     std::new_handler p = f;
     assert(p == &f);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
index 922ab9db4..a9ed3b0cf 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
@@ -14,11 +14,13 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     assert(std::get_new_handler() == 0);
     std::set_new_handler(f1);
     assert(std::get_new_handler() == f1);
     std::set_new_handler(f2);
     assert(std::get_new_handler() == f2);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
index 37c477f13..cff382b0e 100644
--- a/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
+++ b/test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
@@ -14,8 +14,10 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     assert(std::set_new_handler(f1) == 0);
     assert(std::set_new_handler(f2) == f1);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
index de09a7555..0a5265861 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
@@ -83,7 +83,7 @@ void operator delete [] (void* p, std::align_val_t) TEST_NOEXCEPT
 struct alignas(OverAligned) A {};
 struct alignas(std::max_align_t) B {};
 
-int main()
+int main(int, char**)
 {
     reset();
     {
@@ -113,4 +113,6 @@ int main()
         assert(0 == unsized_delete_nothrow_called);
         assert(1 == aligned_delete_called);
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
index bd99495e5..e303c8208 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
@@ -90,7 +90,7 @@ void test_throw_max_size() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A[2];
@@ -103,4 +103,6 @@ int main()
     {
         test_throw_max_size();
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
index a83678769..ed7a53743 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
@@ -92,7 +92,7 @@ void test_max_alloc() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new(std::nothrow) A[3];
@@ -105,4 +105,6 @@ int main()
     {
         test_max_alloc();
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
index 5fbcc5ce7..49aa2bce3 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
@@ -86,7 +86,7 @@ void  operator delete[](void* p, std::align_val_t a) TEST_NOEXCEPT
     --new_called;
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new (std::nothrow) A[2];
@@ -106,4 +106,6 @@ int main()
         assert(!new_called);
         assert(!B_constructed);
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
index 40ba48dec..cb9a2ef7f 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
@@ -66,7 +66,7 @@ void  operator delete[](void* p, std::align_val_t) TEST_NOEXCEPT
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A[3];
@@ -85,4 +85,6 @@ int main()
         delete [] bp;
         assert(!new_called);
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
index 8365b053c..55dc5c753 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
@@ -34,7 +34,7 @@ struct A
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     std::set_new_handler(my_new_handler);
@@ -60,4 +60,6 @@ int main()
     delete [] ap;
     DoNotOptimize(ap);
     assert(A_constructed == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
index 3effc7ea3..b4d8aa349 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
@@ -34,7 +34,7 @@ struct A
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     std::set_new_handler(my_new_handler);
 #ifndef TEST_HAS_NO_EXCEPTIONS
@@ -59,4 +59,6 @@ int main()
     delete [] ap;
     DoNotOptimize(ap);
     assert(A_constructed == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
index a28f7f4f1..4d90aa9a3 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
@@ -43,7 +43,7 @@ struct A
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new (std::nothrow) A[3];
     DoNotOptimize(ap);
@@ -54,4 +54,6 @@ int main()
     DoNotOptimize(ap);
     assert(A_constructed == 0);
     assert(!new_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
index 4ea28241c..e705fc3b4 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
@@ -44,7 +44,7 @@ struct A
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new A[3];
     DoNotOptimize(ap);
@@ -55,4 +55,6 @@ int main()
     DoNotOptimize(ap);
     assert(A_constructed == 0);
     assert(new_called == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
index 482a27e9c..a04ceb6ad 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
index 6183c0c2c..e2a61591a 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
index 1f3921909..5ad81863d 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
index 39de421c2..53af2c764 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
index 686ef66ba..e1a545cc9 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
@@ -54,7 +54,7 @@ void operator delete[](void* p, std::size_t) TEST_NOEXCEPT
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
 
     A* x = new A[3];
@@ -66,4 +66,6 @@ int main()
     assert(1 == unsized_delete_called);
     assert(0 == sized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
index 773a9b992..d69c28be7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
@@ -59,7 +59,7 @@ void operator delete[](void* p, std::size_t) TEST_NOEXCEPT
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
     A* x = new A[3];
     assert(0 == unsized_delete_called);
@@ -70,4 +70,6 @@ int main()
     assert(0 == unsized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
     assert(1 == sized_delete_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
index 2d845e601..026250dae 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
@@ -45,7 +45,7 @@ void operator delete[](void* p, const std::nothrow_t&) TEST_NOEXCEPT
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
     A *x = new A[3];
     DoNotOptimize(x);
@@ -56,4 +56,6 @@ int main()
     DoNotOptimize(x);
     assert(1 == delete_called);
     assert(0 == delete_nothrow_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
index a077fb7ce..41739c0cc 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
@@ -73,7 +73,7 @@ void operator delete[](void* p, std::size_t) TEST_NOEXCEPT
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
     A* x = new A[3];
     assert(0 == unsized_delete_called);
@@ -84,4 +84,6 @@ int main()
     assert(0 == unsized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
     assert(1 == sized_delete_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
index 3cd5e1245..8256b9318 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
@@ -19,11 +19,13 @@ struct A
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     char buf[sizeof(A)];
 
     A* ap = new(buf) A;
     assert((char*)ap == buf);
     assert(A_constructed == 1);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
index 671a3cc05..8a78df6bf 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
@@ -19,7 +19,7 @@ struct A
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     const std::size_t Size = 3;
     // placement new might require additional space.
@@ -30,4 +30,6 @@ int main()
     assert((char*)ap >= buf);
     assert((char*)ap < (buf + ExtraSize));
     assert(A_constructed == Size);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
index b7b17e196..4cba717db 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     char buffer[100];
     ::operator new[](4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
index 7b5eb19d9..05a9b244c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     char buffer[100];
     ::operator new(4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
index 63e797480..22abcba05 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
@@ -82,7 +82,7 @@ void operator delete(void* p, std::align_val_t) TEST_NOEXCEPT
 struct alignas(OverAligned) A {};
 struct alignas(std::max_align_t) B {};
 
-int main()
+int main(int, char**)
 {
     reset();
     {
@@ -112,4 +112,6 @@ int main()
         assert(0 == unsized_delete_nothrow_called);
         assert(1 == aligned_delete_called);
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
index 3c73738d6..448da1717 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
@@ -34,7 +34,7 @@ struct A
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     std::set_new_handler(my_new_handler);
@@ -58,4 +58,6 @@ int main()
     assert(A_constructed);
     delete ap;
     assert(!A_constructed);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
index d0d4b98ae..0d96db5de 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
@@ -90,7 +90,7 @@ void test_throw_max_size() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A;
@@ -103,4 +103,6 @@ int main()
     {
         test_throw_max_size();
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
index d0990c058..4b621f78a 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
@@ -92,7 +92,7 @@ void test_max_alloc() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new(std::nothrow) A;
@@ -105,4 +105,6 @@ int main()
     {
         test_max_alloc();
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
index fa8dc13cf..892eac205 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
@@ -88,7 +88,7 @@ void  operator delete(void* p, std::align_val_t a) TEST_NOEXCEPT
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new (std::nothrow) A;
@@ -108,4 +108,6 @@ int main()
         assert(!new_called);
         assert(!B_constructed);
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
index d37ca28f0..32c27d589 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
@@ -66,7 +66,7 @@ void  operator delete(void* p, std::align_val_t) TEST_NOEXCEPT
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A;
@@ -85,4 +85,6 @@ int main()
         delete bp;
         assert(!new_called);
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
index 6d391645f..dfdf7d77e 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
@@ -34,7 +34,7 @@ struct A
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
     std::set_new_handler(my_new_handler);
 #ifndef TEST_HAS_NO_EXCEPTIONS
@@ -56,4 +56,6 @@ int main()
     assert(A_constructed);
     delete ap;
     assert(!A_constructed);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
index b4217525f..1f186d8b3 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
@@ -43,7 +43,7 @@ struct A
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new (std::nothrow) A;
     DoNotOptimize(ap);
@@ -54,4 +54,6 @@ int main()
     DoNotOptimize(ap);
     assert(!A_constructed);
     assert(!new_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
index 300843b2f..4854c2fb7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
@@ -42,7 +42,7 @@ struct A
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new A;
     DoNotOptimize(ap);
@@ -53,4 +53,6 @@ int main()
     DoNotOptimize(ap);
     assert(!A_constructed);
     assert(!new_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
index 5042a8d1e..4769933d3 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
@@ -18,7 +18,9 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
index e22ea0fdd..a0d99c76d 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
index 617eeae3c..54b25ac55 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
index dd51ad54a..a0bfa8b7f 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
@@ -18,7 +18,9 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4, std::nothrow);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
index 779d7b2ac..69f8bce27 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
@@ -43,7 +43,7 @@ void operator delete(void* p, std::size_t) TEST_NOEXCEPT
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -56,4 +56,6 @@ int main()
     assert(1 == unsized_delete_called);
     assert(0 == sized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
index bed5cc232..deb17d1ae 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
@@ -48,7 +48,7 @@ void operator delete(void* p, std::size_t) TEST_NOEXCEPT
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -61,4 +61,6 @@ int main()
     assert(0 == unsized_delete_called);
     assert(1 == sized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
index 9c54750bd..fbc9cf070 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
@@ -34,7 +34,7 @@ void operator delete(void* p, const std::nothrow_t&) TEST_NOEXCEPT
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -45,4 +45,6 @@ int main()
     DoNotOptimize(x);
     assert(1 == delete_called);
     assert(0 == delete_nothrow_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
index be208b431..3d62040cb 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
@@ -61,7 +61,7 @@ void operator delete(void* p, std::size_t) TEST_NOEXCEPT
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -74,4 +74,6 @@ int main()
     assert(1 == sized_delete_called);
     assert(0 == unsized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp b/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
index 3f105410b..e7252395d 100644
--- a/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
@@ -19,8 +19,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     int *p = nullptr;
     std::launder(p);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
index c3d227183..f9d4da371 100644
--- a/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
@@ -20,7 +20,7 @@
 constexpr int gi = 5;
 constexpr float gf = 8.f;
 
-int main() {
+int main(int, char**) {
     static_assert(std::launder(&gi) == &gi, "" );
     static_assert(std::launder(&gf) == &gf, "" );
 
@@ -31,4 +31,6 @@ int main() {
 
     assert(std::launder(i) == i);
     assert(std::launder(f) == f);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
index f8fd12f1c..d97d00194 100644
--- a/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
@@ -21,7 +21,7 @@
 
 void foo() {}
 
-int main ()
+int main(int, char**)
 {
     void *p = nullptr;
     (void) std::launder((               void *) nullptr);
@@ -32,4 +32,6 @@ int main ()
 
     (void) std::launder(foo);                              // expected-error-re@new:* 1 {{static_assert failed{{.*}} "can't launder functions"}}
     // expected-error@new:* 0-1 {{function pointer argument to '__builtin_launder' is not allowed}}
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp b/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
index c4e1cc7a1..e5f4fbe6d 100644
--- a/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
+++ b/test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_exception>::value),
                  "std::is_base_of<std::exception, std::bad_exception>::value");
@@ -23,4 +23,6 @@ int main()
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/except.nested/assign.pass.cpp b/test/std/language.support/support.exception/except.nested/assign.pass.cpp
index c03f4bbfd..972649579 100644
--- a/test/std/language.support/support.exception/except.nested/assign.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/assign.pass.cpp
@@ -26,7 +26,7 @@ public:
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::nested_exception e0;
@@ -59,4 +59,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp b/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
index cc8c99856..9d65f5fb2 100644
--- a/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
@@ -26,7 +26,7 @@ public:
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::nested_exception e0;
@@ -57,4 +57,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp b/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
index 5aa762cf7..a96c3d015 100644
--- a/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
@@ -26,7 +26,7 @@ public:
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::nested_exception e;
@@ -55,4 +55,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
index 426ea55bf..01ef7ade7 100644
--- a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
@@ -56,7 +56,7 @@ class E1 : public std::nested_exception {};
 class E2 : public std::nested_exception {};
 class E : public E1, public E2 {};
 
-int main()
+int main(int, char**)
 {
     {
         try
@@ -131,4 +131,6 @@ int main()
         }
     }
 
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
index ba81b8fe3..204c3b567 100644
--- a/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
@@ -31,7 +31,7 @@ void go_quietly()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         try
@@ -67,4 +67,6 @@ int main()
             assert(false);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
index c0bc423b0..b63053c33 100644
--- a/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
@@ -42,7 +42,7 @@ public:
 struct Final final {};
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         try
@@ -128,4 +128,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp b/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp b/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
index 2ec624ba6..851d93bc0 100644
--- a/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
@@ -15,10 +15,12 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     assert(std::get_terminate() == f1);
     std::set_terminate(f2);
     assert(std::get_terminate() == f2);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp b/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
index 9eae3a45e..e4464b9af 100644
--- a/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
@@ -15,8 +15,10 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     assert(std::set_terminate(f2) == f1);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp b/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
index 8f889beee..2519f0bc9 100644
--- a/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
@@ -14,9 +14,11 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::terminate_handler, void(*)()>::value), "");
     std::terminate_handler p = f;
     assert(p == &f);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp b/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
index 431ad8bf9..4243fb5ca 100644
--- a/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
+++ b/test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
@@ -17,9 +17,11 @@ void f1()
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     std::terminate();
     assert(false);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/exception/exception.pass.cpp b/test/std/language.support/support.exception/exception/exception.pass.cpp
index bfb27418f..893a7d5b3 100644
--- a/test/std/language.support/support.exception/exception/exception.pass.cpp
+++ b/test/std/language.support/support.exception/exception/exception.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_polymorphic<std::exception>::value,
                  "std::is_polymorphic<std::exception>::value");
@@ -21,4 +21,6 @@ int main()
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/propagation/current_exception.pass.cpp b/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
index 3c265d8bb..c95368163 100644
--- a/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/current_exception.pass.cpp
@@ -29,7 +29,7 @@ struct A
 
 int A::constructed = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::exception_ptr p = std::current_exception();
@@ -270,4 +270,6 @@ int main()
         assert(p != nullptr);
     }
     assert(A::constructed == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp b/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
index 39f2d6014..164e7774b 100644
--- a/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
@@ -15,7 +15,7 @@
 #include <exception>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::exception_ptr p;
     assert(p == nullptr);
@@ -30,4 +30,6 @@ int main()
     assert(p3 == nullptr);
     p3 = nullptr;
     assert(p3 == nullptr);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp b/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
index 3db951d28..b26212fd1 100644
--- a/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::constructed = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::exception_ptr p = std::make_exception_ptr(A(5));
@@ -52,4 +52,6 @@ int main()
         assert(A::constructed == 0);
     }
     assert(A::constructed == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp b/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
index ab2df72e8..015dbef22 100644
--- a/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
+++ b/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::constructed = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::exception_ptr p;
@@ -60,4 +60,6 @@ int main()
         assert(A::constructed == 0);
     }
     assert(A::constructed == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp b/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
index 29087eb15..61cfc8f11 100644
--- a/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
+++ b/test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
@@ -29,7 +29,7 @@ struct B
     }
 };
 
-int main()
+int main(int, char**)
 {
     try
     {
@@ -42,4 +42,6 @@ int main()
         assert(!std::uncaught_exception());
     }
     assert(!std::uncaught_exception());
+
+  return 0;
 }
diff --git a/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp b/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
index bab33d837..c25e4d2e0 100644
--- a/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
+++ b/test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
@@ -41,7 +41,7 @@ struct Outer {
     int d_;
 };
 
-int main () {
+int main(int, char**) {
     assert(std::uncaught_exceptions() == 0);
     {
     Outer o(0);
@@ -58,4 +58,6 @@ int main () {
         }
     }
     assert(std::uncaught_exceptions() == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.general/nothing_to_do.pass.cpp b/test/std/language.support/support.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/support.general/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.initlist/include_cxx03.pass.cpp b/test/std/language.support/support.initlist/include_cxx03.pass.cpp
index 343da95f4..282636ed0 100644
--- a/test/std/language.support/support.initlist/include_cxx03.pass.cpp
+++ b/test/std/language.support/support.initlist/include_cxx03.pass.cpp
@@ -12,6 +12,8 @@
 
 #include <initializer_list>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
index ff532fbf2..097f21a5c 100644
--- a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
@@ -51,11 +51,13 @@ struct B
 
 #endif  // TEST_STD_VER > 11
 
-int main()
+int main(int, char**)
 {
     A test1 = {3, 2, 1};
 #if TEST_STD_VER > 11
     constexpr B test2 = {3, 2, 1};
     (void)test2;
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
diff --git a/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp b/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
index dc5c5ffd4..8d2e0a7e7 100644
--- a/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
@@ -19,7 +19,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     std::initializer_list<A> il;
     assert(il.size() == 0);
@@ -28,4 +28,6 @@ int main()
     constexpr std::initializer_list<A> il2;
     static_assert(il2.size() == 0, "");
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
diff --git a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
index 61bf27084..ec755bfeb 100644
--- a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
@@ -49,11 +49,13 @@ struct B
 
 #endif  // TEST_STD_VER > 11
 
-int main()
+int main(int, char**)
 {
     A test1 = {3, 2, 1};
 #if TEST_STD_VER > 11
     constexpr B test2 = {3, 2, 1};
     (void)test2;
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
diff --git a/test/std/language.support/support.initlist/types.pass.cpp b/test/std/language.support/support.initlist/types.pass.cpp
index 9aad9b3f7..1b48980a2 100644
--- a/test/std/language.support/support.initlist/types.pass.cpp
+++ b/test/std/language.support/support.initlist/types.pass.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::initializer_list<A>::value_type, A>::value), "");
     static_assert((std::is_same<std::initializer_list<A>::reference, const A&>::value), "");
@@ -33,4 +33,6 @@ int main()
     static_assert((std::is_same<std::initializer_list<A>::size_type, std::size_t>::value), "");
     static_assert((std::is_same<std::initializer_list<A>::iterator, const A*>::value), "");
     static_assert((std::is_same<std::initializer_list<A>::const_iterator, const A*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp b/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
index ec144a031..12b80adf0 100644
--- a/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
+++ b/test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
@@ -178,6 +178,8 @@
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/c.limits/climits.pass.cpp b/test/std/language.support/support.limits/c.limits/climits.pass.cpp
index 317d5d509..d124f7ca2 100644
--- a/test/std/language.support/support.limits/c.limits/climits.pass.cpp
+++ b/test/std/language.support/support.limits/c.limits/climits.pass.cpp
@@ -86,6 +86,8 @@
 #error ULLONG_MAX not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp b/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
index 6b48dfbc3..adbd102dc 100644
--- a/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
+++ b/test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
@@ -18,7 +18,7 @@ struct two {one _[2];};
 one test(std::float_round_style);
 two test(int);
 
-int main()
+int main(int, char**)
 {
     static_assert(std::round_indeterminate == -1,
                  "std::round_indeterminate == -1");
@@ -34,4 +34,6 @@ int main()
                  "sizeof(test(std::round_to_nearest)) == 1");
     static_assert(sizeof(test(1)) == 2,
                  "sizeof(test(1)) == 2");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/is_specialized.pass.cpp b/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
index 4959d5f54..b836555af 100644
--- a/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
+++ b/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
@@ -39,7 +39,7 @@ void test()
                  "std::numeric_limits<const volatile T>::is_specialized");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -67,4 +67,6 @@ int main()
     test<long double>();
     static_assert(!std::numeric_limits<std::complex<double> >::is_specialized,
                  "!std::numeric_limits<std::complex<double> >::is_specialized");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
index 012a9a8ee..b5912130a 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
@@ -68,7 +68,7 @@ void test(const T &) {}
 
 struct other {};
 
-int main()
+int main(int, char**)
 {
     // bool
     TEST_NUMERIC_LIMITS(bool)
@@ -205,4 +205,6 @@ int main()
     TEST_NUMERIC_LIMITS(const other)
     TEST_NUMERIC_LIMITS(volatile other)
     TEST_NUMERIC_LIMITS(const volatile other)
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
index d67e8cbab..4f9f62873 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
@@ -26,7 +26,7 @@ test(T expected)
     assert(std::numeric_limits<const volatile T>::denorm_min() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -65,4 +65,6 @@ int main()
 #if !defined(__FLT_DENORM_MIN__) && !defined(FLT_TRUE_MIN)
 #error Test has no expected values for floating point types
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
index de9aa3395..139f4821d 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
@@ -25,7 +25,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::digits == expected, "digits test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 1>();
     test<char, std::numeric_limits<char>::is_signed ? 7 : 8>();
@@ -54,4 +54,6 @@ int main()
     test<float, FLT_MANT_DIG>();
     test<double, DBL_MANT_DIG>();
     test<long double, LDBL_MANT_DIG>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
index 9c2fcfb17..efdfd70d7 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
@@ -29,7 +29,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::is_bounded, "digits10 test 8");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 2>();
@@ -58,4 +58,6 @@ int main()
     test<float, FLT_DIG>();
     test<double, DBL_DIG>();
     test<long double, LDBL_DIG>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
index 691bd5b27..60a905f79 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
@@ -26,7 +26,7 @@ test(T expected)
     assert(std::numeric_limits<const volatile T>::epsilon() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -55,4 +55,6 @@ int main()
     test<float>(FLT_EPSILON);
     test<double>(DBL_EPSILON);
     test<long double>(LDBL_EPSILON);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
index 05469f08c..d5380c1a7 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::has_denorm == expected, "has_denorm test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, std::denorm_absent>();
     test<char, std::denorm_absent>();
@@ -53,4 +53,6 @@ int main()
     test<float, std::denorm_present>();
     test<double, std::denorm_present>();
     test<long double, std::denorm_present>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
index 89bc78a48..77e5de6ab 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::has_denorm_loss == expected, "has_denorm_loss test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@ int main()
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
index abdd9b544..19d4fe293 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::has_infinity == expected, "has_infinity test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@ int main()
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
index a351bcef0..767df5ac2 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::has_quiet_NaN == expected, "has_quiet_NaN test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@ int main()
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
index bc74464e7..0908c49bc 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::has_signaling_NaN == expected, "has_signaling_NaN test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@ int main()
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
index 924f32a6b..0004e4e62 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
@@ -28,7 +28,7 @@ test(T expected)
 
 extern float zero;
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -57,6 +57,8 @@ int main()
     test<float>(1.f/zero);
     test<double>(1./zero);
     test<long double>(1./zero);
+
+  return 0;
 }
 
 float zero = 0;
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
index 8f2cdb0a7..d509be720 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::is_bounded == expected, "is_bounded test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
@@ -53,4 +53,6 @@ int main()
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
index 2c769d87c..30dbd9ea1 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::is_exact == expected, "is_exact test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
@@ -53,4 +53,6 @@ int main()
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
index c7edf178d..215407d74 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::is_iec559 == expected, "is_iec559 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -57,4 +57,6 @@ int main()
 #else
     test<long double, true>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
index 80a45fa29..66ce0cb2b 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::is_integer == expected, "is_integer test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
@@ -53,4 +53,6 @@ int main()
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
index c364fd01b..2eb2c4ba4 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::is_modulo == expected, "is_modulo test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
 //    test<char, false>(); // don't know
@@ -53,4 +53,6 @@ int main()
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
index 08dc5eb77..818ad4db9 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::is_signed == expected, "is_signed test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, char(-1) < char(0)>();
@@ -53,4 +53,6 @@ int main()
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
index bb6ae168e..adf147c70 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
@@ -32,7 +32,7 @@ test(T expected)
     assert(std::numeric_limits<const volatile T>::is_bounded);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(CHAR_MIN);
@@ -61,4 +61,6 @@ int main()
     test<float>(-FLT_MAX);
     test<double>(-DBL_MAX);
     test<long double>(-LDBL_MAX);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
index 0bf7237ad..91f353ab5 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
@@ -32,7 +32,7 @@ test(T expected)
     assert(std::numeric_limits<const volatile T>::is_bounded);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(true);
     test<char>(CHAR_MAX);
@@ -61,4 +61,6 @@ int main()
     test<float>(FLT_MAX);
     test<double>(DBL_MAX);
     test<long double>(LDBL_MAX);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
index 4b8714875..3cf7d5096 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
@@ -25,7 +25,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::max_digits10 == expected, "max_digits10 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@ int main()
     test<float, 2+(FLT_MANT_DIG * 30103)/100000>();
     test<double, 2+(DBL_MANT_DIG * 30103)/100000>();
     test<long double, 2+(LDBL_MANT_DIG * 30103)/100000>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
index 7ce1ac9d7..325ad7979 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
@@ -25,7 +25,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::max_exponent == expected, "max_exponent test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@ int main()
     test<float, FLT_MAX_EXP>();
     test<double, DBL_MAX_EXP>();
     test<long double, LDBL_MAX_EXP>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
index e2bbdde10..e1a4ffe29 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
@@ -25,7 +25,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::max_exponent10 == expected, "max_exponent10 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@ int main()
     test<float, FLT_MAX_10_EXP>();
     test<double, DBL_MAX_10_EXP>();
     test<long double, LDBL_MAX_10_EXP>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
index 66ddaa474..0d2cb3c1b 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
@@ -32,7 +32,7 @@ test(T expected)
     assert(std::numeric_limits<const volatile T>::is_bounded || !std::numeric_limits<const volatile T>::is_signed);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(CHAR_MIN);
@@ -61,4 +61,6 @@ int main()
     test<float>(FLT_MIN);
     test<double>(DBL_MIN);
     test<long double>(LDBL_MIN);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
index 8fb4f09f6..5708d8a20 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
@@ -25,7 +25,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::min_exponent == expected, "min_exponent test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@ int main()
     test<float, FLT_MIN_EXP>();
     test<double, DBL_MIN_EXP>();
     test<long double, LDBL_MIN_EXP>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
index 812dd53bb..f598d42fa 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
@@ -25,7 +25,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::min_exponent10 == expected, "min_exponent10 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@ int main()
     test<float, FLT_MIN_10_EXP>();
     test<double, DBL_MIN_10_EXP>();
     test<long double, LDBL_MIN_10_EXP>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
index 852cf86a1..f4ea61f23 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
@@ -45,7 +45,7 @@ test()
     test_imp<T>(std::is_floating_point<T>());
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -74,4 +74,6 @@ int main()
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
index 8c9e48a2d..8f13768b0 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
@@ -25,7 +25,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::radix == expected, "radix test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 2>();
     test<char, 2>();
@@ -54,4 +54,6 @@ int main()
     test<float, FLT_RADIX>();
     test<double, FLT_RADIX>();
     test<long double, FLT_RADIX>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
index f2d962df4..ddc4490db 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
@@ -26,7 +26,7 @@ test(T expected)
     assert(std::numeric_limits<const volatile T>::round_error() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -55,4 +55,6 @@ int main()
     test<float>(0.5);
     test<double>(0.5);
     test<long double>(0.5);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
index 43e962961..81d4ce6eb 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::round_style == expected, "round_style test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, std::round_toward_zero>();
     test<char, std::round_toward_zero>();
@@ -53,4 +53,6 @@ int main()
     test<float, std::round_to_nearest>();
     test<double, std::round_to_nearest>();
     test<long double, std::round_to_nearest>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
index 312f69714..701386710 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
@@ -45,7 +45,7 @@ test()
     test_imp<T>(std::is_floating_point<T>());
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -74,4 +74,6 @@ int main()
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
index 3e0ad694b..c150e5f23 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::tinyness_before == expected, "tinyness_before test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@ int main()
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
index e71432b18..e7ea38819 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
@@ -31,7 +31,7 @@ test()
     static_assert(std::numeric_limits<const volatile T>::traps == expected, "traps test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, integral_types_trap>();
@@ -60,4 +60,6 @@ int main()
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
index 3c7cefd55..6e258c13a 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
@@ -22,7 +22,7 @@ struct A
 
 bool operator == (const A& x, const A& y) {return x.data_ == y.data_;}
 
-int main()
+int main(int, char**)
 {
     static_assert(std::numeric_limits<A>::is_specialized == false,
                  "std::numeric_limits<A>::is_specialized == false");
@@ -79,4 +79,6 @@ int main()
                  "std::numeric_limits<A>::tinyness_before == false");
     static_assert(std::numeric_limits<A>::round_style == std::round_toward_zero,
                  "std::numeric_limits<A>::round_style == std::round_toward_zero");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp b/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp b/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
index c6a01bf66..b1a4e4450 100644
--- a/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
+++ b/test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
@@ -18,7 +18,7 @@ struct two {one _[2];};
 one test(std::float_denorm_style);
 two test(int);
 
-int main()
+int main(int, char**)
 {
     static_assert(std::denorm_indeterminate == -1,
                  "std::denorm_indeterminate == -1");
@@ -30,4 +30,6 @@ int main()
                  "sizeof(test(std::denorm_present)) == 1");
     static_assert(sizeof(test(1)) == 2,
                  "sizeof(test(1)) == 2");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/nothing_to_do.pass.cpp b/test/std/language.support/support.limits/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/language.support/support.limits/nothing_to_do.pass.cpp
+++ b/test/std/language.support/support.limits/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
index 57234ad43..5458e9194 100644
--- a/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
@@ -188,4 +188,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
index 9bbaca7aa..f5255c0e2 100644
--- a/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
index 85bda4322..d590f9804 100644
--- a/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
@@ -101,4 +101,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
index 3fb2c7ed1..d8f6f548c 100644
--- a/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
@@ -118,4 +118,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
index 6c26e06a0..3e42d06fb 100644
--- a/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp b/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
index 045dcb8ac..2afe2e26b 100644
--- a/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <utility> are defined.
 
@@ -28,4 +28,6 @@ int main()
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
index 9e434c5c2..88da2dcca 100644
--- a/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
@@ -78,4 +78,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
index bcc205358..d81218e66 100644
--- a/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
@@ -87,4 +87,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
index 2864c9f4e..7f1836fba 100644
--- a/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
index c6a9b1648..bcff0bbe1 100644
--- a/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
index 9d9b9bca3..16febf8d3 100644
--- a/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <concepts> are defined.
 
@@ -30,4 +30,6 @@ int main()
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
index 82a0932d0..b18ea07ea 100644
--- a/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
index 53a1b3345..9d07dcdd2 100644
--- a/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
@@ -95,4 +95,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
index c27bdc6b0..1ecebb48f 100644
--- a/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
index 476a31ef9..b05f41bb1 100644
--- a/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <execution> are defined.
 
@@ -30,4 +30,6 @@ int main()
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
index 6638cdee9..d1c09fc7e 100644
--- a/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
@@ -78,4 +78,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
index 102cd29ea..7ecad6d3e 100644
--- a/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
index e11464231..a29a1d708 100644
--- a/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
@@ -241,4 +241,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
index bd2ea2417..23378e0e2 100644
--- a/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
index 9194ff855..3d8fb7a4c 100644
--- a/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
index b1ad28206..9c1719b53 100644
--- a/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
@@ -179,4 +179,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
index bb2005e32..2d2f243e7 100644
--- a/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
index c1159cf73..b736d1f9a 100644
--- a/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
index c5a5b5436..eeea5390a 100644
--- a/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
index c1ecad723..a41dd1b8e 100644
--- a/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
@@ -167,4 +167,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
index 55e595fa9..6c845d71f 100644
--- a/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
@@ -243,4 +243,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
index cb182adc1..d712a8bca 100644
--- a/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <memory_resource> are defined.
 
@@ -30,4 +30,6 @@ int main()
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
diff --git a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
index 4986a1f19..9dae806b8 100644
--- a/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
index 95a717dfb..5f012cd55 100644
--- a/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
@@ -101,4 +101,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
index f44cbc2c7..eb5eb557b 100644
--- a/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
@@ -87,4 +87,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
index 59e698d76..d88fbb0fe 100644
--- a/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
index 17be75c2e..d3ba25867 100644
--- a/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
index 412e29c6c..66becadbb 100644
--- a/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
index d111f263c..2ea98256e 100644
--- a/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
index c886850ce..80cf9c0af 100644
--- a/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
index 12c58480b..7c92dfc08 100644
--- a/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
@@ -110,4 +110,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
index 0f1c37b90..bdd517da0 100644
--- a/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
@@ -170,4 +170,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
index adad6b084..816083e0d 100644
--- a/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
@@ -104,4 +104,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
index e2d986532..5c1e6580c 100644
--- a/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
@@ -153,4 +153,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
index 59994b779..7e8b3de35 100644
--- a/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
@@ -393,4 +393,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
index f6f4e6cec..07eb1a9bc 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
@@ -167,4 +167,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
index 07a3c302a..845318a79 100644
--- a/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
index 6b051d289..1fd38627a 100644
--- a/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
@@ -191,4 +191,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
index 23a15a670..7a1730746 100644
--- a/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
index c22921e77..3ea2a0cf0 100644
--- a/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
@@ -118,4 +118,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
index aa409e154..b85d42d00 100644
--- a/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ b/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -2174,4 +2174,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
diff --git a/test/std/language.support/support.limits/version.pass.cpp b/test/std/language.support/support.limits/version.pass.cpp
index b67df2892..783af5c72 100644
--- a/test/std/language.support/support.limits/version.pass.cpp
+++ b/test/std/language.support/support.limits/version.pass.cpp
@@ -11,6 +11,8 @@
 
 #include <version>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp b/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
index 5f9dc962d..23afd223c 100644
--- a/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
+++ b/test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_cast>::value),
                  "std::is_base_of<std::exception, std::bad_cast>::value");
@@ -23,4 +23,6 @@ int main()
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp b/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
index 90b6bc20a..94424bb03 100644
--- a/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
+++ b/test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_typeid>::value),
                  "std::is_base_of<std::exception, std::bad_typeid>::value");
@@ -23,4 +23,6 @@ int main()
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.rtti/type.info/type_info.pass.cpp b/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
index fec07526a..980bfeecc 100644
--- a/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
+++ b/test/std/language.support/support.rtti/type.info/type_info.pass.cpp
@@ -16,7 +16,7 @@
 bool test_constructor_explicit(std::type_info const&) { return false; }
 bool test_constructor_explicit(std::string const&) { return true; }
 
-int main()
+int main(int, char**)
 {
   {
     const std::type_info& t1 = typeid(int);
@@ -36,4 +36,6 @@ int main()
     // See: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=216201
     assert(test_constructor_explicit("abc"));
   }
+
+  return 0;
 }
diff --git a/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp b/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
index d519622b7..c65f3bbf7 100644
--- a/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
+++ b/test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
@@ -12,11 +12,13 @@
 #include <cstring>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::type_info& t1 = typeid(int);
     const std::type_info& t2 = typeid(int);
     const std::type_info& t3 = typeid(short);
     assert(t1.hash_code() == t2.hash_code());
     assert(t1.hash_code() != t3.hash_code());
+
+  return 0;
 }
diff --git a/test/std/language.support/support.runtime/csetjmp.pass.cpp b/test/std/language.support/support.runtime/csetjmp.pass.cpp
index dc68bf4a3..c1fa71b0e 100644
--- a/test/std/language.support/support.runtime/csetjmp.pass.cpp
+++ b/test/std/language.support/support.runtime/csetjmp.pass.cpp
@@ -15,10 +15,12 @@
 #error setjmp not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::jmp_buf jb;
     ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(std::longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(std::longjmp(jb, 0)), void>::value");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.runtime/csignal.pass.cpp b/test/std/language.support/support.runtime/csignal.pass.cpp
index b827236bb..dcfb4f99f 100644
--- a/test/std/language.support/support.runtime/csignal.pass.cpp
+++ b/test/std/language.support/support.runtime/csignal.pass.cpp
@@ -47,11 +47,13 @@
 #error SIGTERM not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::sig_atomic_t sig = 0;
     ((void)sig);
     typedef void (*func)(int);
     static_assert((std::is_same<decltype(std::signal(0, (func)0)), func>::value), "");
     static_assert((std::is_same<decltype(std::raise(0)), int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.runtime/cstdarg.pass.cpp b/test/std/language.support/support.runtime/cstdarg.pass.cpp
index b3c919af0..8d7fd70b7 100644
--- a/test/std/language.support/support.runtime/cstdarg.pass.cpp
+++ b/test/std/language.support/support.runtime/cstdarg.pass.cpp
@@ -30,8 +30,10 @@
 #error va_start not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::va_list va;
     ((void)va);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.runtime/cstdbool.pass.cpp b/test/std/language.support/support.runtime/cstdbool.pass.cpp
index 98a0e7e49..461e77c99 100644
--- a/test/std/language.support/support.runtime/cstdbool.pass.cpp
+++ b/test/std/language.support/support.runtime/cstdbool.pass.cpp
@@ -26,6 +26,8 @@
 #error false should not be defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.runtime/cstdlib.pass.cpp b/test/std/language.support/support.runtime/cstdlib.pass.cpp
index bc2cfcbb4..d8b663679 100644
--- a/test/std/language.support/support.runtime/cstdlib.pass.cpp
+++ b/test/std/language.support/support.runtime/cstdlib.pass.cpp
@@ -49,7 +49,7 @@ void test_div_struct() {
     ((void) obj);
 };
 
-int main()
+int main(int, char**)
 {
     std::size_t s = 0;
     ((void)s);
@@ -108,4 +108,6 @@ int main()
     static_assert((std::is_same<decltype(std::wctomb(pc,L' ')), int>::value), "");
     static_assert((std::is_same<decltype(std::mbstowcs(pw,"",0)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstombs(pc,pwc,0)), std::size_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.runtime/ctime.pass.cpp b/test/std/language.support/support.runtime/ctime.pass.cpp
index 57fb01245..a8c2dc7ff 100644
--- a/test/std/language.support/support.runtime/ctime.pass.cpp
+++ b/test/std/language.support/support.runtime/ctime.pass.cpp
@@ -26,7 +26,7 @@
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
     std::clock_t c = 0;
     std::size_t s = 0;
@@ -58,4 +58,6 @@ int main()
     ((void)c1); // Prevent unused warning
     ((void)c2); // Prevent unused warning
     static_assert((std::is_same<decltype(std::strftime(c1,s,c2,&tm)), std::size_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.start.term/quick_exit.pass.cpp b/test/std/language.support/support.start.term/quick_exit.pass.cpp
index 5b7c36b08..50d408aa0 100644
--- a/test/std/language.support/support.start.term/quick_exit.pass.cpp
+++ b/test/std/language.support/support.start.term/quick_exit.pass.cpp
@@ -13,10 +13,12 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_QUICK_EXIT
     std::at_quick_exit(f);
     std::quick_exit(0);
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp b/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
index c1703f2be..63c97f210 100644
--- a/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
+++ b/test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
@@ -15,11 +15,13 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_QUICK_EXIT
     std::at_quick_exit(f);
 #else
 #error
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp b/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
index acf10068b..28929b1ae 100644
--- a/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
+++ b/test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
@@ -14,11 +14,13 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_QUICK_EXIT
     std::quick_exit(0);
 #else
 #error
 #endif
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byte.pass.cpp b/test/std/language.support/support.types/byte.pass.cpp
index a4a9e8219..842dc38d3 100644
--- a/test/std/language.support/support.types/byte.pass.cpp
+++ b/test/std/language.support/support.types/byte.pass.cpp
@@ -30,4 +30,6 @@ static_assert(!std::is_same<std::byte, unsigned char>::value, "" );
 // The standard doesn't outright say this, but it's pretty clear that it has to be true.
 static_assert(sizeof(std::byte) == 1, "" );
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/language.support/support.types/byteops/and.assign.pass.cpp b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
index e4875d38f..9ecdb5f6c 100644
--- a/test/std/language.support/support.types/byteops/and.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
@@ -20,7 +20,7 @@ constexpr std::byte test(std::byte b1, std::byte b2) {
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -35,4 +35,6 @@ int main () {
     static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
     static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
     static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/and.pass.cpp b/test/std/language.support/support.types/byteops/and.pass.cpp
index 312e679cd..d1dbc75f7 100644
--- a/test/std/language.support/support.types/byteops/and.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator&(byte l, byte r) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
     constexpr std::byte b9{static_cast<std::byte>(9)};
@@ -27,4 +27,6 @@ int main () {
     static_assert(std::to_integer<int>(b8 & b1) ==  0, "");
     static_assert(std::to_integer<int>(b9 & b1) ==  1, "");
     static_assert(std::to_integer<int>(b9 & b8) ==  8, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp b/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
index 99660b6b1..5111667ce 100644
--- a/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
+++ b/test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
@@ -14,7 +14,9 @@
 // XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
 // XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
 
-int main () {
+int main(int, char**) {
   constexpr std::byte b{42};
   static_assert(std::to_integer<int>(b) == 42, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
index 413b62b1f..8f2134b20 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
@@ -25,6 +25,8 @@ constexpr std::byte test(std::byte b) {
     }
 
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1 = test(std::byte{1});
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
index 9fe86883f..3647f5c64 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
@@ -22,7 +22,7 @@ constexpr std::byte test(std::byte b) {
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b2{static_cast<std::byte>(2)};
     constexpr std::byte b3{static_cast<std::byte>(3)};
@@ -32,4 +32,6 @@ int main () {
     static_assert(std::to_integer<int>(test(b2)) ==  8, "" );
     static_assert(std::to_integer<int>(test(b3)) == 12, "" );
 
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.fail.cpp b/test/std/language.support/support.types/byteops/lshift.fail.cpp
index 6d889ed23..83ce5b81e 100644
--- a/test/std/language.support/support.types/byteops/lshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.fail.cpp
@@ -16,7 +16,9 @@
 // These functions shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2 = b1 << 2.0f;
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.pass.cpp b/test/std/language.support/support.types/byteops/lshift.pass.cpp
index 73cc66373..855eebdf4 100644
--- a/test/std/language.support/support.types/byteops/lshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.pass.cpp
@@ -16,7 +16,7 @@
 // These functions shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b3{static_cast<std::byte>(3)};
 
@@ -26,4 +26,6 @@ int main () {
     static_assert(std::to_integer<int>(b1 << 2) ==   4, "");
     static_assert(std::to_integer<int>(b3 << 4) ==  48, "");
     static_assert(std::to_integer<int>(b3 << 6) == 192, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/not.pass.cpp b/test/std/language.support/support.types/byteops/not.pass.cpp
index cb94e3659..d6252aa35 100644
--- a/test/std/language.support/support.types/byteops/not.pass.cpp
+++ b/test/std/language.support/support.types/byteops/not.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator~(byte b) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2{static_cast<std::byte>(2)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -23,4 +23,6 @@ int main () {
     static_assert(std::to_integer<int>(~b1) == 254, "");
     static_assert(std::to_integer<int>(~b2) == 253, "");
     static_assert(std::to_integer<int>(~b8) == 247, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/or.assign.pass.cpp b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
index cad3acef3..1216b852b 100644
--- a/test/std/language.support/support.types/byteops/or.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
@@ -20,7 +20,7 @@ constexpr std::byte test(std::byte b1, std::byte b2) {
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2{static_cast<std::byte>(2)};
@@ -36,4 +36,6 @@ int main () {
     static_assert(std::to_integer<int>(test(b8, b1)) ==  9, "");
     static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
 
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/or.pass.cpp b/test/std/language.support/support.types/byteops/or.pass.cpp
index 4b778398d..69b5bfaac 100644
--- a/test/std/language.support/support.types/byteops/or.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator|(byte l, byte r) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2{static_cast<std::byte>(2)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -27,4 +27,6 @@ int main () {
     static_assert(std::to_integer<int>(b2 | b1) ==  3, "");
     static_assert(std::to_integer<int>(b8 | b1) ==  9, "");
     static_assert(std::to_integer<int>(b8 | b2) == 10, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
index dcd656734..714f5cd8b 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
@@ -25,6 +25,8 @@ constexpr std::byte test(std::byte b) {
     }
 
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1 = test(std::byte{1});
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
index bbb921240..b1ca9d851 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
@@ -22,7 +22,7 @@ constexpr std::byte test(std::byte b) {
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b16{static_cast<std::byte>(16)};
     constexpr std::byte b192{static_cast<std::byte>(192)};
@@ -31,4 +31,6 @@ int main () {
 
     static_assert(std::to_integer<int>(test(b16))  ==  4, "" );
     static_assert(std::to_integer<int>(test(b192)) == 48, "" );
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.fail.cpp b/test/std/language.support/support.types/byteops/rshift.fail.cpp
index 1dc5f83cf..6af06f4fc 100644
--- a/test/std/language.support/support.types/byteops/rshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.fail.cpp
@@ -16,7 +16,9 @@
 // These functions shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2 = b1 >> 2.0f;
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.pass.cpp b/test/std/language.support/support.types/byteops/rshift.pass.cpp
index 2ca3c6c20..64db7556c 100644
--- a/test/std/language.support/support.types/byteops/rshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.pass.cpp
@@ -22,7 +22,7 @@ constexpr std::byte test(std::byte b) {
     }
 
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b100{static_cast<std::byte>(100)};
     constexpr std::byte b115{static_cast<std::byte>(115)};
 
@@ -33,4 +33,6 @@ int main () {
     static_assert(std::to_integer<int>(b115 >> 3) ==  14, "");
     static_assert(std::to_integer<int>(b115 >> 6) ==   1, "");
 
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/to_integer.fail.cpp b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
index ea3836b16..64996358c 100644
--- a/test/std/language.support/support.types/byteops/to_integer.fail.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
@@ -16,7 +16,9 @@
 // This function shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     auto f = std::to_integer<float>(b1);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/to_integer.pass.cpp b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
index cdae92ac4..657d17d9c 100644
--- a/test/std/language.support/support.types/byteops/to_integer.pass.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
@@ -16,7 +16,7 @@
 // This function shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b3{static_cast<std::byte>(3)};
 
@@ -27,4 +27,6 @@ int main () {
 
     static_assert(std::to_integer<int>(b1) == 1, "");
     static_assert(std::to_integer<int>(b3) == 3, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
index 8caeec7dc..c82a6fd19 100644
--- a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
@@ -20,7 +20,7 @@ constexpr std::byte test(std::byte b1, std::byte b2) {
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -35,4 +35,6 @@ int main () {
     static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
     static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
     static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/byteops/xor.pass.cpp b/test/std/language.support/support.types/byteops/xor.pass.cpp
index 1dbf07f36..150f455b1 100644
--- a/test/std/language.support/support.types/byteops/xor.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator^(byte l, byte r) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
     constexpr std::byte b9{static_cast<std::byte>(9)};
@@ -27,4 +27,6 @@ int main () {
     static_assert(std::to_integer<int>(b8 ^ b1) == 9, "");
     static_assert(std::to_integer<int>(b9 ^ b1) == 8, "");
     static_assert(std::to_integer<int>(b9 ^ b8) == 1, "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/max_align_t.pass.cpp b/test/std/language.support/support.types/max_align_t.pass.cpp
index 50c4f5ef5..a49f598df 100644
--- a/test/std/language.support/support.types/max_align_t.pass.cpp
+++ b/test/std/language.support/support.types/max_align_t.pass.cpp
@@ -15,7 +15,7 @@
 #include <stdio.h>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
 #if TEST_STD_VER > 17
@@ -40,4 +40,6 @@ int main()
                   std::alignment_of<void*>::value,
                   "std::alignment_of<std::max_align_t>::value >= "
                   "std::alignment_of<void*>::value");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/null.pass.cpp b/test/std/language.support/support.types/null.pass.cpp
index ce8530a00..66ecdbc14 100644
--- a/test/std/language.support/support.types/null.pass.cpp
+++ b/test/std/language.support/support.types/null.pass.cpp
@@ -12,6 +12,8 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/nullptr_t.pass.cpp b/test/std/language.support/support.types/nullptr_t.pass.cpp
index 01a674a0a..14ab3c65d 100644
--- a/test/std/language.support/support.types/nullptr_t.pass.cpp
+++ b/test/std/language.support/support.types/nullptr_t.pass.cpp
@@ -74,7 +74,7 @@ void test_nullptr_conversions() {
 #endif
 
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::nullptr_t) == sizeof(void*),
                   "sizeof(std::nullptr_t) == sizeof(void*)");
@@ -103,4 +103,6 @@ int main()
         test_comparisons<void(*)()>();
     }
     test_nullptr_conversions();
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp b/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
index e6dc3772b..5802e46f1 100644
--- a/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
+++ b/test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
@@ -10,7 +10,9 @@
 
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     std::ptrdiff_t i = static_cast<std::ptrdiff_t>(nullptr);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp b/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
index ab1f447cd..b7696df97 100644
--- a/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
+++ b/test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
@@ -16,8 +16,10 @@
 #include <cstddef>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ptrdiff_t i = reinterpret_cast<std::ptrdiff_t>(nullptr);
     assert(i == 0);
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/offsetof.pass.cpp b/test/std/language.support/support.types/offsetof.pass.cpp
index 4a9dfac5e..756f55352 100644
--- a/test/std/language.support/support.types/offsetof.pass.cpp
+++ b/test/std/language.support/support.types/offsetof.pass.cpp
@@ -21,7 +21,9 @@ struct A
     int x;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(noexcept(offsetof(A, x)), "");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/ptrdiff_t.pass.cpp b/test/std/language.support/support.types/ptrdiff_t.pass.cpp
index 9c6c36f38..de6f7726f 100644
--- a/test/std/language.support/support.types/ptrdiff_t.pass.cpp
+++ b/test/std/language.support/support.types/ptrdiff_t.pass.cpp
@@ -15,7 +15,7 @@
 //  2. be the same sizeof as void*.
 //  3. be a signed integral.
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::ptrdiff_t) == sizeof(void*),
                   "sizeof(std::ptrdiff_t) == sizeof(void*)");
@@ -23,4 +23,6 @@ int main()
                   "std::is_signed<std::ptrdiff_t>::value");
     static_assert(std::is_integral<std::ptrdiff_t>::value,
                   "std::is_integral<std::ptrdiff_t>::value");
+
+  return 0;
 }
diff --git a/test/std/language.support/support.types/size_t.pass.cpp b/test/std/language.support/support.types/size_t.pass.cpp
index ba1f64673..5c840457b 100644
--- a/test/std/language.support/support.types/size_t.pass.cpp
+++ b/test/std/language.support/support.types/size_t.pass.cpp
@@ -15,7 +15,7 @@
 //  2. be the same sizeof as void*.
 //  3. be an unsigned integral.
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::size_t) == sizeof(void*),
                   "sizeof(std::size_t) == sizeof(void*)");
@@ -23,4 +23,6 @@ int main()
                   "std::is_unsigned<std::size_t>::value");
     static_assert(std::is_integral<std::size_t>::value,
                   "std::is_integral<std::size_t>::value");
+
+  return 0;
 }
diff --git a/test/std/localization/c.locales/clocale.pass.cpp b/test/std/localization/c.locales/clocale.pass.cpp
index 8217dd74d..d8bd81b2b 100644
--- a/test/std/localization/c.locales/clocale.pass.cpp
+++ b/test/std/localization/c.locales/clocale.pass.cpp
@@ -43,7 +43,7 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::lconv lc;
     ((void)lc); // Prevent unused warning
@@ -51,4 +51,6 @@ int main()
     static_assert((std::is_same<decltype(std::setlocale(0, "")), char*>::value), "");
 #endif
     static_assert((std::is_same<decltype(std::localeconv()), std::lconv*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
index 33a94f990..1d76fa609 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
@@ -32,7 +32,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -68,4 +68,6 @@ int main()
                              s3.data(), s3.data() + s3.size()) == 1);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
index 21cf03681..40c15d6e9 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::locale l(LOCALE_en_US_UTF_8);
     {
@@ -39,4 +39,6 @@ int main()
         assert(f.hash(x1.data(), x1.data() + x1.size())
             != f.hash(x2.data(), x2.data() + x2.size()));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
index 7cd3d0fe5..0b86979f5 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -53,4 +53,6 @@ int main()
             assert(f.transform(x.data(), x.data() + x.size()) == x);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
index f00c8fd95..f4dfd6522 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::locale l(LOCALE_en_US_UTF_8);
     {
@@ -43,4 +43,6 @@ int main()
         assert(&std::use_facet<std::collate<wchar_t> >(l)
             == &std::use_facet<std::collate_byname<wchar_t> >(l));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
index ded9ebae3..856074d39 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 template <class C> int my_facet<C>::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet<char>);
@@ -63,4 +63,6 @@ int main()
         assert(my_facet<wchar_t>::count == 1);
     }
     assert(my_facet<wchar_t>::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
index ff5aa4bdd..bfbbebe39 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
@@ -16,7 +16,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -45,4 +45,6 @@ int main()
         assert(f.compare(ib+1, ib+3, ia, ia+sa) == 1);
         assert(f.compare(ia, ia+3, ib, ib+3) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
index 61d5a640f..07e29b17f 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -35,4 +35,6 @@ int main()
         assert(f.hash(x1.data(), x1.data() + x1.size())
             != f.hash(x2.data(), x2.data() + x2.size()));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
index 7b8c9915f..7588a82be 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         const std::collate<wchar_t>& f = std::use_facet<std::collate<wchar_t> >(l);
         assert(f.transform(x.data(), x.data() + x.size()) == x);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp b/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
index 45957c3be..63e2739f4 100644
--- a/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -47,4 +47,6 @@ int main()
         static_assert((std::is_same<std::collate<wchar_t>::string_type, std::wstring>::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::collate<wchar_t> >::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
index 92024149c..b7da91b46 100644
--- a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
@@ -38,7 +38,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     assert(std::ctype_base::space);
     assert(std::ctype_base::print);
@@ -74,4 +74,6 @@ int main()
     test(std::ctype_base::blank);
     test(std::ctype_base::alnum);
     test(std::ctype_base::graph);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
index 5ba7a67e4..e38af450f 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new std::ctype<char>);
@@ -36,4 +36,6 @@ int main()
         assert(globalMemCounter.checkDeleteArrayCalledEq(0));
     }
     assert(globalMemCounter.checkDeleteArrayCalledEq(1));
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
index 20eef3354..4ec37db02 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
@@ -29,7 +29,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -46,4 +46,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
index c4561f796..562f6c25e 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -55,4 +55,6 @@ int main()
         assert(f.is(F::graph, '.'));
         assert(!f.is(F::graph,  '\x07'));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
index 9415d8b5a..c073a955e 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -114,4 +114,6 @@ int main()
         assert( (m[5] & F::alnum));
         assert( (m[5] & F::graph));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
index b0fa41a2f..d2fa02201 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.narrow('a', '*') == 'a');
         assert(f.narrow('1', '*') == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
index 01bb80534..481469540 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@ int main()
         assert(v[4] == 'a');
         assert(v[5] == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
index 3f4f04902..043ca6796 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@ int main()
         assert(f.scan_is(F::alnum, in.data(), in.data() + in.size()) - in.data() == 1);
         assert(f.scan_is(F::graph, in.data(), in.data() + in.size()) - in.data() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
index 6cd24a82e..066a06a7f 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@ int main()
         assert(f.scan_not(F::alnum, in.data(), in.data() + in.size()) - in.data() == 0);
         assert(f.scan_not(F::graph, in.data(), in.data() + in.size()) - in.data() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
index 9d815196b..6a0fea0b1 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::ctype<char> F;
     {
@@ -29,4 +29,6 @@ int main()
         const F& f = std::use_facet<F>(l);
         assert(f.table() == table);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
index 2b817002c..ddf4fbdb0 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.tolower('a') == 'a');
         assert(f.tolower('1') == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
index 036ed25c6..b307d4627 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@ int main()
         assert(in[4] == 'a');
         assert(in[5] == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
index c393bb91b..8b5505910 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.toupper('a') == 'A');
         assert(f.toupper('1') == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
index 25af985f7..3d1c453cf 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@ int main()
         assert(in[4] == 'A');
         assert(in[5] == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
index 5b9f74bad..81c3ab6b3 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.widen('a') == 'a');
         assert(f.widen('1') == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
index ab3a838c0..35d9335c2 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@ int main()
         assert(v[4] == 'a');
         assert(v[5] == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
index 1aef57d3f..7f46238d6 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::ctype<char> F;
     assert(F::classic_table() != 0);
@@ -55,4 +55,6 @@ int main()
         assert(((p[i] & ~set) & defined) == 0);   // no extra ones
     }
 
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
index b23f9ef83..c46dbb3e6 100644
--- a/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -35,4 +35,6 @@ int main()
         static_assert((std::is_base_of<std::ctype_base, std::ctype<char> >::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::ctype<char> >::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
index d5cde4754..03d17375e 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
@@ -36,7 +36,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet(LOCALE_en_US));
@@ -68,4 +68,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
index 4d2803815..eedf192db 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
@@ -34,7 +34,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet("en_US"));
@@ -66,4 +66,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
index 50bf58349..8e5d70356 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
@@ -34,7 +34,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet("en_US"));
@@ -66,4 +66,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
index 2379b1631..5503192ca 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
@@ -38,7 +38,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet(LOCALE_en_US_UTF_8));
@@ -70,4 +70,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
index f6b94c5f1..c2e40542e 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
@@ -17,10 +17,12 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::codecvt_base::ok == 0);
     assert(std::codecvt_base::partial == 1);
     assert(std::codecvt_base::error == 2);
     assert(std::codecvt_base::noconv == 3);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
index e12d30168..3f0dc9e7c 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
index e0ed00dfd..e2df342d4 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
@@ -35,7 +35,7 @@ int my_facet::count = 0;
 
 //#endif
 
-int main()
+int main(int, char**)
 {
 //#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     {
@@ -54,4 +54,6 @@ int main()
     }
     assert(my_facet::count == 0);
 //#endif
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
index 56d63764d..0df7f3515 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
@@ -35,7 +35,7 @@ int my_facet::count = 0;
 
 //#endif
 
-int main()
+int main(int, char**)
 {
 //#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     {
@@ -54,4 +54,6 @@ int main()
     }
     assert(my_facet::count == 0);
 //#endif
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
index 8f4293ee8..6917e1b72 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
index 2f84eb6c9..e1741aec0 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
index 4a30c4ee8..f4614984a 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
index 6a883d3d4..2a6a07ef9 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const char from[] = "some text";
@@ -36,4 +36,6 @@ int main()
     assert(to_next - to == 9);
     for (unsigned i = 0; i < 9; ++i)
         assert(to[i] == from[i]);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
index a48b902e1..038ae9711 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@ int main()
     assert(f.length(mbs, from, from+10, 9) == 9);
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
index 69c711f60..bcaa70528 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 4);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
index 9b5d0f988..cff42b0c0 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
@@ -23,7 +23,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -41,4 +41,6 @@ int main()
         for (unsigned i = 0; i < 9; ++i)
             assert(to[i] == from[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
index bde44c088..5b027bae7 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
@@ -20,7 +20,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<char> to(3);
@@ -29,4 +29,6 @@ int main()
     char* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(to_next == to.data());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
index 2ef1e5c65..2b2f136e3 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
index 834bd6076..0d2f35fc2 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
index 8472a5692..eb7c53fce 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const char from[] = "some text";
@@ -36,4 +36,6 @@ int main()
     assert(to_next - to == 9);
     for (unsigned i = 0; i < 9; ++i)
         assert(to[i] == static_cast<char32_t>(from[i]));
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
index 6986314e3..da8530688 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@ int main()
     assert(f.length(mbs, from, from+10, 9) == 9);
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
index 921ec1854..f31dba747 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 4);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
index 210f8c052..7ed560943 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
@@ -23,7 +23,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -41,4 +41,6 @@ int main()
         for (unsigned i = 0; i < 9; ++i)
             assert(static_cast<char32_t>(to[i]) == from[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
index 26981d3c8..aaf9a6a20 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
@@ -20,7 +20,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<char> to(3);
@@ -29,4 +29,6 @@ int main()
     char* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(to_next == to.data());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
index 2590c2b0e..c253bbed7 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.always_noconv());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
index 571ab84d8..79c26add6 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 1);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
index 2b7c610e4..1f2cdb6be 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const std::basic_string<F::intern_type> from("some text");
@@ -34,4 +34,6 @@ int main()
                      to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(from_next == from.data());
     assert(to_next == to.data());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
index b930009b5..ad45cba5f 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@ int main()
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 11) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
index adc0b1707..437e72b94 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 1);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
index 28b4be745..be266746c 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const std::basic_string<F::intern_type> from("some text");
@@ -34,4 +34,6 @@ int main()
                       to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(from_next == from.data());
     assert(to_next == to.data());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
index 56c10aa52..a3d9e3d14 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
@@ -20,7 +20,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<char> to(3);
@@ -29,4 +29,6 @@ int main()
     char* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(to_next == to.data());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
index 2d338dd8e..eaae7b6e9 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
@@ -20,7 +20,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char32_t, char, std::mbstate_t> F32_8;
     typedef std::codecvt<char16_t, char, std::mbstate_t> F16_8;
@@ -123,4 +123,6 @@ int main()
             assert(c32 == c32x);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
index df6451747..484b2213d 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
index ed33018b2..9c075af13 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 1);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
index 7ca632e4e..bec0e6cb0 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
@@ -22,7 +22,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const std::basic_string<F::extern_type> from("some text");
@@ -39,4 +39,6 @@ int main()
     assert(static_cast<std::size_t>(to_next - to.data()) == expected.size());
     assert(static_cast<std::size_t>(to_next - to.data()) == expected.size());
     assert(to == expected);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
index 0fcab1af7..4fd5d3293 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@ int main()
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 11) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
index fefd11016..90d913151 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 1);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
index 8769b8814..bc12bdbce 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
@@ -23,7 +23,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -67,4 +67,6 @@ int main()
         assert(static_cast<std::size_t>(to_next - to.data()) == to.size()-1);
         assert(to.data() == std::string("some te"));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
index 9241c7a47..e0f7c3c95 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
@@ -22,7 +22,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<F::extern_type> to(3);
@@ -31,4 +31,6 @@ int main()
     F::extern_type* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::ok);
     assert(to_next == to.data());
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
index 12fee2682..455cf03ee 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@ int main()
     const F& f = std::use_facet<F>(l);
     ((void)f); // Prevent unused warning
     (void)F::id;
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
index b01bd5a7a..f52c60f1b 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char16_t, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@ int main()
     const F& f = std::use_facet<F>(l);
     (void)F::id;
     ((void)f);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
index 6ad469754..c75de419c 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char32_t, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@ int main()
     const F& f = std::use_facet<F>(l);
     (void)F::id;
     ((void)f);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
index 6c19e41a8..07e25be71 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@ int main()
     const F& f = std::use_facet<F>(l);
     ((void)f); // Prevent unused warning
     (void)F::id;
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
index 32acd85d1..3331c5a67 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -108,4 +108,6 @@ int main()
             assert(!f.is(F::upper, L'\x00DA'));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
index 1087b88c0..6751fd60d 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -243,4 +243,6 @@ int main()
             assert( (m[6] & F::graph));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
index 45d90ddd5..3a6360eb9 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -49,4 +49,6 @@ int main()
             assert( cf.is(CF::alpha,  'a'));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
index 19d751d29..6d1937725 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::string(LOCALE_fr_CA_ISO8859_1));
@@ -52,4 +52,6 @@ int main()
             assert(f.narrow(L'\xDA', '*') == '*');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
index c51b97311..7ab4874fb 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_fr_CA_ISO8859_1);
@@ -60,4 +60,6 @@ int main()
             assert(v[6] == '*');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
index 6c875863f..b736dd786 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -67,4 +67,6 @@ int main()
             assert(f.scan_is(F::graph, in.data(), in.data() + in.size()) - in.data() == 2);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
index dbeeae4c6..fa7674a8c 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -67,4 +67,6 @@ int main()
             assert(f.scan_not(F::graph, in.data(), in.data() + in.size()) - in.data() == 0);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
index 3f9ab9dce..ab5daa7aa 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -88,4 +88,6 @@ int main()
             assert(f.tolower(L'\xFA') == L'\xFA');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
index 29021e0f4..29403cb10 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -94,4 +94,6 @@ int main()
             assert(in[6] == L'1');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
index b9c882c9a..56304a755 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -90,4 +90,6 @@ int main()
             assert(f.toupper(L'\xFA') == L'\xFA');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
index 2b0669cb3..bfc3bf848 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -94,4 +94,6 @@ int main()
             assert(in[6] == L'1');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
index 9ec946816..ce0a0e30e 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -56,4 +56,6 @@ int main()
                 == &std::use_facet<std::ctype_byname<wchar_t> >(l));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
index 5752bb82b..1dc9b7de8 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -61,4 +61,6 @@ int main()
 #endif
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
index 4f5efca1d..67a97ba68 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -67,4 +67,6 @@ int main()
 #endif
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
index e41b93b78..f53d4e964 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
@@ -30,7 +30,7 @@ public:
 
 template <class C> int my_facet<C>::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet<wchar_t>);
@@ -47,4 +47,6 @@ int main()
         assert(my_facet<wchar_t>::count == 1);
     }
     assert(my_facet<wchar_t>::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
index a48f75f4f..23a1aa9d2 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -55,4 +55,6 @@ int main()
         assert(f.is(F::graph, L'.'));
         assert(!f.is(F::graph,  L'\x07'));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
index f348d2080..d9dd5b58a 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -114,4 +114,6 @@ int main()
         assert( (m[5] & F::alnum));
         assert( (m[5] & F::graph));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
index 1e1194bda..55e1f378b 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.narrow(L'a', '*') == 'a');
         assert(f.narrow(L'1', '*') == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
index 523fb2503..47c2b5188 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@ int main()
         assert(v[4] == 'a');
         assert(v[5] == '1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
index 23718fec1..1891b155b 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@ int main()
         assert(f.scan_is(F::alnum, in.data(), in.data() + in.size()) - in.data() == 1);
         assert(f.scan_is(F::graph, in.data(), in.data() + in.size()) - in.data() == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
index 22bc14701..40cc8c0fa 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@ int main()
         assert(f.scan_not(F::alnum, in.data(), in.data() + in.size()) - in.data() == 0);
         assert(f.scan_not(F::graph, in.data(), in.data() + in.size()) - in.data() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
index b5c402de2..1ae14410c 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.tolower(L'a') == L'a');
         assert(f.tolower(L'1') == L'1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
index 92bbc8ceb..711343d3c 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@ int main()
         assert(in[4] == L'a');
         assert(in[5] == L'1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
index 0ed6e4504..fbc28a1b8 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.toupper(L'a') == L'A');
         assert(f.toupper(L'1') == L'1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
index 0510778eb..963e894a7 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@ int main()
         assert(in[4] == L'A');
         assert(in[5] == L'1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
index 1737de8f0..c2570a311 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@ int main()
         assert(f.widen('a') == L'a');
         assert(f.widen('1') == L'1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
index 3942268eb..a43817a25 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@ int main()
         assert(v[4] == L'a');
         assert(v[5] == L'1');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp b/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
index 89ac905a2..35b5d3282 100644
--- a/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -35,4 +35,6 @@ int main()
         static_assert((std::is_base_of<std::ctype_base, std::ctype<wchar_t> >::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::ctype<wchar_t> >::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
index df42b522c..ddbbe6669 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
index 994a97211..c0166f80f 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
@@ -28,6 +28,8 @@ public:
         : std::messages<CharT>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
index 7f2e4f9b9..ce6d70be7 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
@@ -17,7 +17,9 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::messages_base mb;
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp b/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
index 454d9b182..436290698 100644
--- a/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::messages<char> >::value), "");
     static_assert((std::is_base_of<std::messages_base, std::messages<char> >::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::messages<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::messages<char>::string_type, std::string>::value), "");
     static_assert((std::is_same<std::messages<wchar_t>::string_type, std::wstring>::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
index f70f8eead..360ff3ad6 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
index 94f9bd7a9..9fec21f51 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
@@ -43,7 +43,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -719,4 +719,6 @@ int main()
             assert(err == std::ios_base::failbit);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
index 27ae11eed..292f5eaea 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
@@ -76,7 +76,7 @@ static std::wstring convert_thousands_sep(std::wstring const& in) {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_fr_FR_UTF_8);
@@ -753,4 +753,6 @@ int main()
             assert(ex == 123456789);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
index b543799ac..c13849804 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
@@ -55,7 +55,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_ru_RU_UTF_8);
@@ -735,4 +735,6 @@ int main()
             assert(ex == -123456789);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
index 20ba6f491..9b006f55b 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
@@ -49,7 +49,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_zh_CN_UTF_8);
@@ -725,4 +725,6 @@ int main()
             assert(err == std::ios_base::failbit);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
index a5cb05334..1b1a471e1 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
@@ -43,7 +43,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -727,4 +727,6 @@ int main()
             assert(ex == L"");
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
index 9ad7528c2..7bc04801e 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::money_get<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::money_get<wchar_t> >::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::money_get<wchar_t>::iter_type, std::istreambuf_iterator<wchar_t> >::value), "");
     static_assert((std::is_same<std::money_get<char>::string_type, std::string>::value), "");
     static_assert((std::is_same<std::money_get<wchar_t>::string_type, std::wstring>::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
index bdbb0b6cd..309d26c5d 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
index 28f7451e9..d6e4d6cc1 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
@@ -43,7 +43,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -490,4 +490,6 @@ int main()
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
index e9e916a3c..72f3f6570 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
@@ -78,7 +78,7 @@ static std::wstring convert_thousands_sep(std::wstring const& in) {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_fr_FR_UTF_8);
@@ -524,4 +524,6 @@ int main()
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
index 1894144db..36f97b1d8 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
@@ -55,7 +55,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_ru_RU_UTF_8);
@@ -501,4 +501,6 @@ int main()
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
index 0a3d478ec..a300ba847 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
@@ -49,7 +49,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_zh_CN_UTF_8);
@@ -495,4 +495,6 @@ int main()
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
index ab4a5c603..cd1ff643f 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
@@ -43,7 +43,7 @@ public:
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -490,4 +490,6 @@ int main()
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
index 27c2ff5d6..bd797313c 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::money_put<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::money_put<wchar_t> >::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::money_put<wchar_t>::iter_type, std::ostreambuf_iterator<wchar_t> >::value), "");
     static_assert((std::is_same<std::money_put<char>::string_type, std::string>::value), "");
     static_assert((std::is_same<std::money_put<wchar_t>::string_type, std::wstring>::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
index f04ff4fb6..43a2fbc17 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
@@ -75,7 +75,7 @@ static bool glibc_version_less_than(char const* version) {
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -179,4 +179,6 @@ int main()
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.curr_symbol() == L"CNY ");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
index a64388ca5..bec52e6ab 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
@@ -56,7 +56,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -153,4 +153,6 @@ int main()
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.decimal_point() == L'.');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
index 9bbc76868..07d78229a 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
@@ -55,7 +55,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -141,4 +141,6 @@ int main()
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.frac_digits() == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
index 7ff50db73..2c2da4864 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
@@ -60,7 +60,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     // Monetary grouping strings may be terminated with 0 or CHAR_MAX, defining
     // how the grouping is repeated.
@@ -149,4 +149,6 @@ int main()
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.grouping() == "\3");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
index 6cd00de65..f3f637b60 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
@@ -60,7 +60,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -226,4 +226,6 @@ int main()
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
index 6857810bd..5567fc08e 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
@@ -55,7 +55,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -141,4 +141,6 @@ int main()
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.negative_sign() == L"-");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
index ff3cdcdb2..f7d396a66 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
@@ -60,7 +60,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -226,4 +226,6 @@ int main()
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
index 50a7ca939..43dfa2a2f 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
@@ -55,7 +55,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -141,4 +141,6 @@ int main()
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.positive_sign() == L"");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
index e0bfd88a8..c789c4e5b 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
@@ -59,7 +59,7 @@ public:
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -170,4 +170,6 @@ int main()
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.thousands_sep() == L',');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
index 4717d4c0f..3b52f7afc 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
index 577322425..7b3b75a19 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
@@ -53,7 +53,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@ int main()
         Fwt f(1);
         assert(f.curr_symbol() == std::wstring());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
index 206f32535..34d02032c 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
@@ -53,7 +53,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@ int main()
         Fwt f(1);
         assert(f.decimal_point() == std::numeric_limits<wchar_t>::max());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
index b27ecd6df..50365584d 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
@@ -53,7 +53,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@ int main()
         Fwt f(1);
         assert(f.frac_digits() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
index e959ad8ab..9e12e3220 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
@@ -53,7 +53,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@ int main()
         Fwt f(1);
         assert(f.grouping() == std::string());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
index e9950b1a7..cb5119909 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
@@ -50,7 +50,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -84,4 +84,6 @@ int main()
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
index 3ef5e84fc..6f134e784 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
@@ -54,7 +54,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -72,4 +72,6 @@ int main()
         Fwt f(1);
         assert(f.negative_sign() == L"-");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
index 3c3034bbe..bff44a69d 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
@@ -50,7 +50,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -84,4 +84,6 @@ int main()
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
index dbe3e4ba7..8686e2005 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
@@ -53,7 +53,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@ int main()
         Fwt f(1);
         assert(f.positive_sign() == std::wstring());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
index 7b24c6dc9..42d28d096 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
@@ -53,7 +53,7 @@ public:
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@ int main()
         Fwt f(1);
         assert(f.thousands_sep() == std::numeric_limits<wchar_t>::max());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
index d02c3b43e..58f04905a 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
@@ -18,7 +18,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::money_base mb; ((void)mb);
     static_assert(std::money_base::none == 0, "");
@@ -29,4 +29,6 @@ int main()
     static_assert(sizeof(std::money_base::pattern) == 4, "");
     std::money_base::pattern p;
     p.field[0] = std::money_base::none;
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
index 439f8c31f..24ddadfb3 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
@@ -29,7 +29,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::moneypunct<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::moneypunct<wchar_t> >::value), "");
@@ -44,4 +44,6 @@ int main()
     test(std::moneypunct<char, true>::intl);
     test(std::moneypunct<wchar_t, false>::intl);
     test(std::moneypunct<wchar_t, true>::intl);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
index afb58d5e2..5a3af4b95 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
index 0c71a7354..79aa68dde 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
@@ -39,7 +39,7 @@ protected:
     virtual string_type do_falsename() const {return "no";}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -96,4 +96,6 @@ int main()
             assert(ex == "yes");
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
index 0d30bbf70..062d5cfd4 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
@@ -17876,7 +17876,7 @@ void test8()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -17886,4 +17886,6 @@ int main()
     test6();
     test7();
     test8();
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
index 5cf9bfa1f..1aee8bdfe 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
@@ -39,7 +39,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -340,4 +340,6 @@ int main()
         assert(ex == "-***1_00_0");
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
index 5fcc0e464..3e71a1dfb 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
@@ -26206,7 +26206,7 @@ void test12()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -26246,4 +26246,6 @@ int main()
     {
         long double v = std::nan(""); ((void)v);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
index 18d96754b..a3c49d36a 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
@@ -39,7 +39,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -340,4 +340,6 @@ int main()
         assert(ex == "-***1_00_0");
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
index f4fdf7620..d366c3842 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
@@ -28,7 +28,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -45,4 +45,6 @@ int main()
         assert(rc > 0);
         assert(ex == expected_str);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
index 98aba106c..420d22fb0 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
@@ -39,7 +39,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -343,4 +343,6 @@ int main()
                                                  : "18_446_744_073_709_550_61_6"));
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
index ccebb6ce1..1ad3065c0 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
@@ -39,7 +39,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -340,4 +340,6 @@ int main()
         assert(ex == "18_446_744_073_709_550_61_6");
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
index 19e8ceeb0..6011c75c1 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::num_put<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::num_put<wchar_t> >::value), "");
@@ -28,4 +28,6 @@ int main()
     static_assert((std::is_same<std::num_put<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::num_put<char>::iter_type, std::ostreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::num_put<wchar_t>::iter_type, std::ostreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
index 2929fb05e..096939d08 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
index 8b4a33e84..b577d96b7 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
@@ -51,7 +51,7 @@ protected:
     virtual string_type do_falsename() const {return "ab";}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -226,4 +226,6 @@ int main()
         assert(err == ios.goodbit);
         assert(b == true);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
index 7e896f705..3980d488d 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
@@ -48,7 +48,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -278,4 +278,6 @@ int main()
         assert(err == ios.goodbit);
         assert(std::abs(v - 3.14159265358979e+10)/3.14159265358979e+10 < 1.e-8);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
index aa7ffcb78..1ac313f7d 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
@@ -35,7 +35,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -208,4 +208,6 @@ int main()
         assert(err == ios.goodbit);
         assert(v == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
index 02f2ba6dc..135117286 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
@@ -41,7 +41,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -517,4 +517,6 @@ int main()
         assert(err == ios.failbit);
         assert(v == std::numeric_limits<long>::max());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
index 89fa436a9..49e8ae750 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
@@ -35,7 +35,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -267,4 +267,6 @@ int main()
         assert(err == ios.goodbit);
         assert(v == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
index 9f8153c6b..c3a66a983 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
@@ -40,7 +40,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -102,4 +102,6 @@ int main()
         const long long expect = 0x8000000000000000LL;
         assert(v == expect);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
index 2388dce5f..23b6ad932 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
@@ -29,7 +29,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -57,4 +57,6 @@ int main()
         assert(err == ios.goodbit);
         assert(p == (void*)0x73);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
index 36aafc2f4..8a1ee3914 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
@@ -40,7 +40,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@ int main()
         assert(err == ios.goodbit);
         assert(v == 0xFFFFFFFF);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
index 47b58b34e..e97c460c7 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
@@ -40,7 +40,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@ int main()
         assert(err == ios.goodbit);
         assert(v == 0xFFFFFFFF);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
index 3518c30a0..a5d57df05 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
@@ -40,7 +40,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@ int main()
         assert(err == ios.goodbit);
         assert(v == 0xFFFFFFFFFFFFFFFFULL);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
index f83148a1d..261cac372 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
@@ -40,7 +40,7 @@ protected:
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@ int main()
         assert(err == ios.goodbit);
         assert(v == 0xFFFF);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
index 5c6de9709..92cbeda61 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
@@ -51,7 +51,7 @@ void check_limits()
     }
 }
 
-int main()
+int main(int, char**)
 {
     check_limits<short>();
     check_limits<unsigned short>();
@@ -61,4 +61,6 @@ int main()
     check_limits<unsigned long>();
     check_limits<long long>();
     check_limits<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
index 4faa4155e..07a22cb6e 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
@@ -148,7 +148,7 @@ void test_negate() {
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_neg_one<long>();
     test_neg_one<long long>();
@@ -161,4 +161,6 @@ int main()
     test_negate<unsigned int>();
     test_negate<unsigned long>();
     test_negate<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp b/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
index ab8c00ede..42f210d39 100644
--- a/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::num_get<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::num_get<wchar_t> >::value), "");
@@ -28,4 +28,6 @@ int main()
     static_assert((std::is_same<std::num_get<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::num_get<char>::iter_type, std::istreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::num_get<wchar_t>::iter_type, std::istreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
index b779be50f..30624ecc8 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
@@ -33,7 +33,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
@@ -51,4 +51,6 @@ int main()
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.date_order() == std::time_base::ymd);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
index 62ca19784..d62071b94 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
@@ -33,7 +33,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
@@ -51,4 +51,6 @@ int main()
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.date_order() == std::time_base::ymd);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
index 5c0a5ff59..e5b591325 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
@@ -44,7 +44,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -98,4 +98,6 @@ int main()
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
index 7dd82ed63..5506e4cac 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
@@ -44,7 +44,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -97,4 +97,6 @@ int main()
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
index 787d4a00e..5311a8565 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
@@ -36,7 +36,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -71,4 +71,6 @@ int main()
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
index a975bc962..e45260a66 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
@@ -45,7 +45,7 @@ public:
         : F2(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -80,4 +80,6 @@ int main()
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
index c63fab2aa..bda40c56d 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
@@ -42,7 +42,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -167,4 +167,6 @@ int main()
         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
index 6c8d86e12..d8715f825 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
@@ -42,7 +42,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -169,4 +169,6 @@ int main()
         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
index bdb61c66d..a007415d0 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
@@ -37,7 +37,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -90,4 +90,6 @@ int main()
         assert(t.tm_sec == 15);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
index b0e8b1c39..0e2481d6a 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
@@ -37,7 +37,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -90,4 +90,6 @@ int main()
         assert(t.tm_sec == 15);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
index 342c87a48..308b08529 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
@@ -40,7 +40,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -87,4 +87,6 @@ int main()
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
index c2566095f..c52462e37 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
@@ -40,7 +40,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -85,4 +85,6 @@ int main()
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
index a53cd059b..09df42371 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
@@ -36,7 +36,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -81,4 +81,6 @@ int main()
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
index 93ae51e55..78c35e969 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
@@ -36,7 +36,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -81,4 +81,6 @@ int main()
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
index a920c5cb9..6fb9899de 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
index e14d1c57f..47b06e9df 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
@@ -26,8 +26,10 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     assert(f.date_order() == std::time_base::mdy);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
index 3f95fd3b4..1a1dae754 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -47,4 +47,6 @@ int main()
         assert(t.tm_year == 105);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
index e7f19a5da..1fe184bea 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -47,4 +47,6 @@ int main()
         assert(t.tm_year == 105);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
index 22b2825c8..2416f6275 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -64,4 +64,6 @@ int main()
         assert(t.tm_min == 27);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
index e7b86c791..8e61dcca8 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -261,4 +261,6 @@ int main()
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
index 78d32ece4..a8eb4864e 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -261,4 +261,6 @@ int main()
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
index fb8b49808..0c6d9085b 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
@@ -29,7 +29,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -301,4 +301,6 @@ int main()
         assert(i.base() == in+sizeof(in)-1);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
index c2523dc5d..ca0227973 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -113,4 +113,6 @@ int main()
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
index f78359c91..98f2a8570 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -113,4 +113,6 @@ int main()
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
index f972a63bf..16e853a49 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -216,4 +216,6 @@ int main()
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
index 3e6e982bd..3b7b4e9d8 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
@@ -30,7 +30,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -216,4 +216,6 @@ int main()
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
index 210112f8e..8a0b84059 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
@@ -29,7 +29,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -134,4 +134,6 @@ int main()
         assert(t.tm_year == 1099);
         assert(err == std::ios_base::goodbit);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
index c046a7de6..c1b509b40 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
@@ -17,7 +17,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::time_base::dateorder d = std::time_base::no_order;
     ((void)d); // Prevent unused warning
@@ -26,4 +26,6 @@ int main()
     assert(std::time_base::mdy == 2);
     assert(std::time_base::ymd == 3);
     assert(std::time_base::ydm == 4);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
index ba0dd69e4..bd74f7da8 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
@@ -27,7 +27,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::time_get<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::time_get<wchar_t> >::value), "");
@@ -37,4 +37,6 @@ int main()
     static_assert((std::is_same<std::time_get<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::time_get<char>::iter_type, std::istreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::time_get<wchar_t>::iter_type, std::istreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
index 30f1eef6e..cd7013327 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
@@ -45,7 +45,7 @@ public:
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     char str[200];
     output_iterator<char*> iter;
@@ -77,4 +77,6 @@ int main()
         assert((ex == "Today is Samedi which is abbreviated Sam.")||
                (ex == "Today is samedi which is abbreviated sam." ));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
index 2010ef4ff..9d0ec1ad7 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
@@ -31,7 +31,7 @@ public:
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@ int main()
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
index 24971f48f..94faa80f1 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
@@ -27,7 +27,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     char str[200];
@@ -57,4 +57,6 @@ int main()
         std::string ex(str, iter.base());
         assert(ex == "The number of the month is 05.");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
index 9bef3e787..a3b6cf5b2 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
@@ -27,7 +27,7 @@ public:
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     char str[200];
@@ -328,4 +328,6 @@ int main()
         std::string ex(str, iter.base());
         assert(ex == "%");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp b/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
index c638624d0..4361094f4 100644
--- a/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::time_put<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::time_put<wchar_t> >::value), "");
@@ -28,4 +28,6 @@ int main()
     static_assert((std::is_same<std::time_put<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::time_put<char>::iter_type, std::ostreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::time_put<wchar_t>::iter_type, std::ostreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
index cddc1497e..f8132872d 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -61,4 +61,6 @@ int main()
             assert(np.decimal_point() == L',');
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
index c6e67dbfb..4dbc7e7b8 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -70,4 +70,6 @@ int main()
             assert(np.grouping() == group);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
index 7d6978a93..256900240 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -84,4 +84,6 @@ int main()
             assert(np.thousands_sep() == wsep);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
index 39d0de277..e3a10a5c3 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
@@ -30,7 +30,7 @@ public:
 
 template <class C> int my_facet<C>::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet<char>);
@@ -62,4 +62,6 @@ int main()
         assert(my_facet<wchar_t>::count == 1);
     }
     assert(my_facet<wchar_t>::count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
index 43385c023..5322c8a87 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@ int main()
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.decimal_point() == L'.');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
index 7cbf9b43a..d1f20f3bb 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@ int main()
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.falsename() == std::wstring(L"false"));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
index 2ce956df7..4c23c51ac 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@ int main()
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.grouping() == std::string());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
index cc47edbf2..2044c98a1 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@ int main()
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.thousands_sep() == L',');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
index 96fb3011d..359c96bef 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@ int main()
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.truename() == std::wstring(L"true"));
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
index 236d9460d..212670af4 100644
--- a/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -46,4 +46,6 @@ int main()
         static_assert((std::is_same<std::numpunct<wchar_t>::string_type, std::wstring>::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::numpunct<wchar_t> >::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp b/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
index 160594850..def721c4a 100644
--- a/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
@@ -18,11 +18,13 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::consume_header == 4);
     assert(std::generate_header == 2);
     assert(std::little_endian == 1);
     std::codecvt_mode e = std::consume_header;
     assert(e == 4);
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
index 22be9593b..a66129610 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -38,4 +38,6 @@ int main()
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
index 91d95af9a..6bd37789d 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -41,4 +41,6 @@ int main()
         bool r = c.always_noconv();
         assert(r == false);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
index d3fbea6dc..2e8a1833c 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -41,4 +41,6 @@ int main()
         int r = c.encoding();
         assert(r == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
index e44783564..4ccf933d6 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
@@ -24,7 +24,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<char32_t> C;
@@ -735,4 +735,6 @@ int main()
         assert(np == n+2);
         assert(w == 0x56);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
index 4e6fdf858..39ecb8f0e 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
@@ -22,7 +22,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -445,4 +445,6 @@ int main()
         r = c.length(m, n, n+2, 2);
         assert(r == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
index 6422d5679..fa8c3269a 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -59,4 +59,6 @@ int main()
         int r = c.max_length();
         assert(r == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
index afd1e6ad6..beabf842e 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
@@ -346,7 +346,9 @@ void TestHelper<CharT, 4>::test() {
   }
 }
 
-int main() {
+int main(int, char**) {
   TestHelper<char32_t>::test();
   TestHelper<wchar_t>::test();
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
index 2471ccb19..2c37e2578 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
@@ -23,7 +23,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -52,4 +52,6 @@ int main()
         std::codecvt_base::result r = c.unshift(m, n, n+4, np);
         assert(r == std::codecvt_base::noconv);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
index f350b62ca..450f52509 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -38,4 +38,6 @@ int main()
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
index 167521573..7d7ba19be 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -41,4 +41,6 @@ int main()
         bool r = c.always_noconv();
         assert(r == false);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
index 324546d99..d8e689f62 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -41,4 +41,6 @@ int main()
         int r = c.encoding();
         assert(r == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
index 4f5d3d8fb..611d06305 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
@@ -24,7 +24,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<char32_t> C;
@@ -356,4 +356,6 @@ int main()
         assert(np == n+1);
         assert(w == 0x56);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
index 4b5e096af..2df1c9603 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
@@ -22,7 +22,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -240,4 +240,6 @@ int main()
         r = c.length(m, n, n+1, 3);
         assert(r == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
index a353ad6cf..57e5f5850 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -59,4 +59,6 @@ int main()
         int r = c.max_length();
         assert(r == 7);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
index 430b5c254..f8b56bcb6 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
@@ -318,8 +318,10 @@ void TestHelper<CharT, 4>::test() {
   }
 }
 
-int main() {
+int main(int, char**) {
   TestHelper<wchar_t>::test();
   TestHelper<char32_t>::test();
   TestHelper<char16_t>::test();
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
index 344b3e503..a41f99797 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
@@ -23,7 +23,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -52,4 +52,6 @@ int main()
         std::codecvt_base::result r = c.unshift(m, n, n+4, np);
         assert(r == std::codecvt_base::noconv);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
index 6d658624e..c7fe09caf 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -41,4 +41,6 @@ int main()
         bool r = c.always_noconv();
         assert(r == false);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
index a392c8a25..595f7888e 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -41,4 +41,6 @@ int main()
         int r = c.encoding();
         assert(r == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
index aab52fdf1..482521032 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
@@ -234,10 +234,12 @@ void TestHelper<CharT, 4>::test() {
   }
 }
 
-int main() {
+int main(int, char**) {
 #ifndef _WIN32
   TestHelper<wchar_t>::test();
 #endif
   TestHelper<char32_t>::test();
   TestHelper<char16_t>::test();
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
index 172a8734d..33a4b5f04 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
@@ -22,7 +22,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -231,4 +231,6 @@ int main()
         r = c.length(m, n, n+1, 2);
         assert(r == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
index 247e0ce20..5d93d929e 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -59,4 +59,6 @@ int main()
         int r = c.max_length();
         assert(r == 7);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
index 846df2156..89908eb77 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
@@ -299,10 +299,12 @@ void TestHelper<CharT, 4>::test() {
   }
 }
 
-int main() {
+int main(int, char**) {
 #ifndef _WIN32
   TestHelper<wchar_t>::test();
 #endif
   TestHelper<char32_t>::test();
   TestHelper<char16_t>::test();
+
+  return 0;
 }
diff --git a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
index 96139bd5b..79b670055 100644
--- a/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
+++ b/test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
@@ -23,7 +23,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -52,4 +52,6 @@ int main()
         std::codecvt_base::result r = c.unshift(m, n, n+4, np);
         assert(r == std::codecvt_base::noconv);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locale.syn/nothing_to_do.pass.cpp b/test/std/localization/locale.syn/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locale.syn/nothing_to_do.pass.cpp
+++ b/test/std/localization/locale.syn/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
index 68b9b9f1b..2cf9e4b57 100644
--- a/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isalnum(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert( std::isalnum('f', l));
     assert( std::isalnum('9', l));
     assert(!std::isalnum('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
index 0e5a777b3..800c26cb9 100644
--- a/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isalpha(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert( std::isalpha('f', l));
     assert(!std::isalpha('9', l));
     assert(!std::isalpha('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp b/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
index afca98b70..d5cd4a6b9 100644
--- a/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::iscntrl(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert(!std::iscntrl('f', l));
     assert(!std::iscntrl('9', l));
     assert(!std::iscntrl('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
index 35a4540fd..2e71bd394 100644
--- a/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isdigit(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert(!std::isdigit('f', l));
     assert( std::isdigit('9', l));
     assert(!std::isdigit('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
index 3b4d0c551..406b7cbf9 100644
--- a/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isgraph(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert( std::isgraph('f', l));
     assert( std::isgraph('9', l));
     assert( std::isgraph('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp b/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
index 057b70226..2fc9ece02 100644
--- a/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::islower(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert( std::islower('f', l));
     assert(!std::islower('9', l));
     assert(!std::islower('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
index 990fc03eb..36fa16cbc 100644
--- a/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert( std::isprint(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert( std::isprint('f', l));
     assert( std::isprint('9', l));
     assert( std::isprint('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp b/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
index b9fb94a3c..db1133780 100644
--- a/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::ispunct(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert(!std::ispunct('f', l));
     assert(!std::ispunct('9', l));
     assert( std::ispunct('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
index b00ba46e6..62e50d2fc 100644
--- a/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert( std::isspace(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert(!std::isspace('f', l));
     assert(!std::isspace('9', l));
     assert(!std::isspace('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
index c5863beb3..c986c7cdd 100644
--- a/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isupper(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert(!std::isupper('f', l));
     assert(!std::isupper('9', l));
     assert(!std::isupper('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp b/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
index 4a77628db..245f2ed60 100644
--- a/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isxdigit(' ', l));
@@ -27,4 +27,6 @@ int main()
     assert( std::isxdigit('f', l));
     assert( std::isxdigit('9', l));
     assert(!std::isxdigit('+', l));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
index c16755e20..f28abb934 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
 #if TEST_STD_VER > 11
@@ -55,4 +55,6 @@ int main()
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
index 66f95df53..7c4042885 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
@@ -37,7 +37,7 @@ struct test_buf
     virtual int_type overflow(int_type c = traits_type::eof()) {return base::overflow(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ofstream bs("overflow.dat");
@@ -96,4 +96,6 @@ int main()
         assert(f.get() == -1);
     }
     std::remove("overflow.dat");
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
index f268f9a21..dc4144b15 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
@@ -37,7 +37,7 @@ struct test_buf
     virtual int_type pbackfail(int_type c = traits_type::eof()) {return base::pbackfail(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream bs("underflow.dat");
@@ -55,4 +55,6 @@ int main()
         assert(f.sbumpc() == L'2');
         assert(f.sgetc() == L'3');
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
index ffd5a0df7..b58d1d8eb 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
     {
@@ -27,4 +27,6 @@ int main()
         b.rdbuf(s.rdbuf());
         assert(b.rdbuf() == s.rdbuf());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
index 4494d56c7..b50f10cc1 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
@@ -31,7 +31,7 @@ public:
     ~test_codecvt() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         wchar_t buf[10];
@@ -54,4 +54,6 @@ int main()
         assert(f.sgetc() == L'l');
     }
     std::remove("seekoff.dat");
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
index 1816ad0c7..0541dbfb9 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
     {
@@ -25,4 +25,6 @@ int main()
         std::mbstate_t s = b.state();
         ((void)s);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
index c22fb6a14..e309f3eb6 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
@@ -15,7 +15,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ofstream bytestream("myfile.txt");
@@ -32,4 +32,6 @@ int main()
         assert(ws == L"Hello");
     }
     std::remove("myfile.txt");
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
index 523778f23..6d04935b3 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
@@ -37,7 +37,7 @@ struct test_buf
     virtual int_type underflow() {return base::underflow();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream bs("underflow.dat");
@@ -80,4 +80,6 @@ int main()
         assert(f.sbumpc() == 0x4E53);
         assert(f.sbumpc() == test_buf::traits_type::eof());
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
index 72b939dfb..9885dca53 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(std::tolower(' ', l) == ' ');
@@ -27,4 +27,6 @@ int main()
     assert(std::tolower('f', l) == 'f');
     assert(std::tolower('9', l) == '9');
     assert(std::tolower('+', l) == '+');
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
index dbd936529..34f675b05 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(std::toupper(' ', l) == ' ');
@@ -27,4 +27,6 @@ int main()
     assert(std::toupper('f', l) == 'F');
     assert(std::toupper('9', l) == '9');
     assert(std::toupper('+', l) == '+');
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
index b52bbc0bb..802aaf65d 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
@@ -61,4 +61,6 @@ void TestHelper<CharT, 4>::test() {
   }
 }
 
-int main() { TestHelper<wchar_t>::test(); }
+int main(int, char**) { TestHelper<wchar_t>::test(); 
+  return 0;
+}
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
index 578547f8e..3efd26fb4 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> Codecvt;
@@ -36,4 +36,6 @@ int main()
         static_assert( std::is_constructible<Myconv, Codecvt*>::value, "");
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
index 0e58bc225..6e2d5ff5e 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
@@ -16,7 +16,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> Codecvt;
@@ -24,4 +24,6 @@ int main()
         Myconv myconv(new Codecvt, std::mbstate_t());
         assert(myconv.converted() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
index c1a874dc2..d035c3160 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
@@ -21,10 +21,12 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
     static_assert(!std::is_copy_constructible<Myconv>::value, "");
     static_assert(!std::is_copy_assignable<Myconv>::value, "");
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
index 364cfed80..e284c13c0 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
@@ -70,4 +70,6 @@ int main()
         std::wstring ws = myconv.from_bytes('\xA5');
         assert(ws == L"wide error");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
index e527f31a1..c1a26d055 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
@@ -68,4 +68,6 @@ void TestHelper<CharT, 4>::test() {
   }
 }
 
-int main() { TestHelper<wchar_t>::test(); }
+int main(int, char**) { TestHelper<wchar_t>::test(); 
+  return 0;
+}
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
index 0fb5b9f34..a7588dc25 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
@@ -15,11 +15,13 @@
 #include <locale>
 #include <codecvt>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
     Myconv myconv;
     std::mbstate_t s = myconv.state();
     ((void)s);
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
index 2e4dce8bd..397ba6494 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
@@ -68,4 +68,6 @@ void TestHelper<CharT, 4>::test() {
   }
 }
 
-int main() { TestHelper<wchar_t>::test(); }
+int main(int, char**) { TestHelper<wchar_t>::test(); 
+  return 0;
+}
diff --git a/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
index eb67ecffc..c2dea9a90 100644
--- a/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <locale>
 #include <codecvt>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv;
@@ -31,4 +31,6 @@ int main()
         static_assert((std::is_same<myconv::state_type, std::mbstate_t>::value), "");
         static_assert((std::is_same<myconv::int_type, std::char_traits<wchar_t>::int_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp b/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp b/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp b/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
index a895b1aa1..66539d1ea 100644
--- a/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
+++ b/test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
@@ -21,11 +21,13 @@ struct my_facet
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
     std::locale loc;
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(!std::has_facet<my_facet>(loc));
     std::locale loc2(loc, new my_facet);
     assert(std::has_facet<my_facet>(loc2));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp b/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
index c7f53975d..3c2cb6042 100644
--- a/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
+++ b/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
@@ -30,7 +30,7 @@ struct my_facet
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
@@ -53,4 +53,6 @@ int main()
         assert(facet_count == 1);
     }
     assert(facet_count == 0);
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/assign.pass.cpp b/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
index 02b5f1096..369fee4cb 100644
--- a/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/assign.pass.cpp
@@ -56,7 +56,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -67,4 +67,6 @@ int main()
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp b/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
index 5424a8b92..c324f394c 100644
--- a/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
@@ -61,7 +61,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -94,4 +94,6 @@ int main()
         std::locale ok("");
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/copy.pass.cpp b/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
index 885dfea37..4f96ab415 100644
--- a/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/copy.pass.cpp
@@ -54,7 +54,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_fr_FR_UTF_8);
@@ -64,4 +64,6 @@ int main()
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/default.pass.cpp b/test/std/localization/locales/locale/locale.cons/default.pass.cpp
index 8f79b1842..5c1e922cb 100644
--- a/test/std/localization/locales/locale/locale.cons/default.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/default.pass.cpp
@@ -53,7 +53,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     int ok;
     {
@@ -73,4 +73,6 @@ int main()
         assert(globalMemCounter.checkOutstandingNewEq(ok));
     }
     assert(globalMemCounter.checkOutstandingNewEq(ok));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
index d0ccb8a34..70f2cb92b 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
@@ -59,7 +59,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -68,4 +68,6 @@ int main()
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
index 498682f28..35c06ce50 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
@@ -65,7 +65,7 @@ struct my_facet
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -85,4 +85,6 @@ int main()
         assert(loc == loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
index 79db6f044..ba54e8554 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
@@ -59,7 +59,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -68,4 +68,6 @@ int main()
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp b/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
index 5fdde6c67..3cb3aadac 100644
--- a/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
@@ -60,7 +60,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -69,4 +69,6 @@ int main()
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.cons/string.pass.cpp b/test/std/localization/locales/locale/locale.cons/string.pass.cpp
index 449b9fbc2..55b2f88c2 100644
--- a/test/std/localization/locales/locale/locale.cons/string.pass.cpp
+++ b/test/std/localization/locales/locale/locale.cons/string.pass.cpp
@@ -55,7 +55,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(std::string(LOCALE_ru_RU_UTF_8));
@@ -69,4 +69,6 @@ int main()
         assert(loc != loc3);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.members/combine.pass.cpp b/test/std/localization/locales/locale/locale.members/combine.pass.cpp
index 1a867fbfa..fc1f3d33b 100644
--- a/test/std/localization/locales/locale/locale.members/combine.pass.cpp
+++ b/test/std/localization/locales/locale/locale.members/combine.pass.cpp
@@ -63,7 +63,7 @@ struct my_facet
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
 {
     {
@@ -95,4 +95,6 @@ int main()
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }
 #endif
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.members/name.pass.cpp b/test/std/localization/locales/locale/locale.members/name.pass.cpp
index 3a6e1b98c..96ebdf391 100644
--- a/test/std/localization/locales/locale/locale.members/name.pass.cpp
+++ b/test/std/localization/locales/locale/locale.members/name.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc;
@@ -27,4 +27,6 @@ int main()
         std::locale loc(LOCALE_en_US_UTF_8);
         assert(loc.name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.operators/compare.pass.cpp b/test/std/localization/locales/locale/locale.operators/compare.pass.cpp
index b42e55ff6..ea083d137 100644
--- a/test/std/localization/locales/locale/locale.operators/compare.pass.cpp
+++ b/test/std/localization/locales/locale/locale.operators/compare.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -30,4 +30,6 @@ int main()
             assert(l(s3, s2));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.operators/eq.pass.cpp b/test/std/localization/locales/locale/locale.operators/eq.pass.cpp
index aeb877086..1efb487bc 100644
--- a/test/std/localization/locales/locale/locale.operators/eq.pass.cpp
+++ b/test/std/localization/locales/locale/locale.operators/eq.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::locale cloc;
     std::locale copy(cloc);
@@ -82,4 +82,6 @@ int main()
     assert(noname2 != noname1);
     assert(noname2 != nonamec);
     assert(noname2 == noname2);
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.statics/classic.pass.cpp b/test/std/localization/locales/locale/locale.statics/classic.pass.cpp
index 9060ae27d..7594edcc2 100644
--- a/test/std/localization/locales/locale/locale.statics/classic.pass.cpp
+++ b/test/std/localization/locales/locale/locale.statics/classic.pass.cpp
@@ -48,11 +48,13 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     std::locale loc = std::locale::classic();
     assert(loc.name() == "C");
     assert(loc == std::locale("C"));
     check(loc);
     check(std::locale("C"));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.statics/global.pass.cpp b/test/std/localization/locales/locale/locale.statics/global.pass.cpp
index 961bb2f4c..57f55aa1a 100644
--- a/test/std/localization/locales/locale/locale.statics/global.pass.cpp
+++ b/test/std/localization/locales/locale/locale.statics/global.pass.cpp
@@ -52,7 +52,7 @@ void check(const std::locale& loc)
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     std::locale loc;
     assert(loc.name() == "C");
@@ -61,4 +61,6 @@ int main()
     std::locale loc2;
     check(loc2);
     assert(loc2 == std::locale(LOCALE_en_US_UTF_8));
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
index 7724ffd00..11c3de297 100644
--- a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
@@ -23,7 +23,7 @@ template <class T>
 void test(const T &) {}
 
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::locale::category, int>::value), "");
     assert(std::locale::none == 0);
@@ -55,4 +55,6 @@ int main()
     test(std::locale::time);
     test(std::locale::messages);
     test(std::locale::all);
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp b/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locales/locale/nothing_to_do.pass.cpp b/test/std/localization/locales/locale/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locales/locale/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/locale/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/locales/nothing_to_do.pass.cpp b/test/std/localization/locales/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/locales/nothing_to_do.pass.cpp
+++ b/test/std/localization/locales/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/localization/localization.general/nothing_to_do.pass.cpp b/test/std/localization/localization.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/localization/localization.general/nothing_to_do.pass.cpp
+++ b/test/std/localization/localization.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/nothing_to_do.pass.cpp b/test/std/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/nothing_to_do.pass.cpp
+++ b/test/std/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/c.math/cmath.pass.cpp b/test/std/numerics/c.math/cmath.pass.cpp
index fa9048643..3f9a5f557 100644
--- a/test/std/numerics/c.math/cmath.pass.cpp
+++ b/test/std/numerics/c.math/cmath.pass.cpp
@@ -1514,7 +1514,7 @@ void test_trunc()
     assert(std::trunc(1) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test_abs();
     test_acos();
@@ -1586,4 +1586,6 @@ int main()
     test_scalbn();
     test_tgamma();
     test_trunc();
+
+  return 0;
 }
diff --git a/test/std/numerics/c.math/ctgmath.pass.cpp b/test/std/numerics/c.math/ctgmath.pass.cpp
index c2ea8e875..4cba6031a 100644
--- a/test/std/numerics/c.math/ctgmath.pass.cpp
+++ b/test/std/numerics/c.math/ctgmath.pass.cpp
@@ -10,10 +10,12 @@
 
 #include <ctgmath>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     (void)cd;
     double x = std::sin(0);
     ((void)x); // Prevent unused warning
+
+  return 0;
 }
diff --git a/test/std/numerics/c.math/tgmath_h.pass.cpp b/test/std/numerics/c.math/tgmath_h.pass.cpp
index c58827cb4..3fab28b04 100644
--- a/test/std/numerics/c.math/tgmath_h.pass.cpp
+++ b/test/std/numerics/c.math/tgmath_h.pass.cpp
@@ -10,6 +10,8 @@
 
 #include <tgmath.h>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp b/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
index 671e4d12d..613784392 100644
--- a/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
+++ b/test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
@@ -57,7 +57,7 @@
 #error FE_DFL_ENV not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::fenv_t fenv;
     std::fexcept_t fex;
@@ -74,4 +74,6 @@ int main()
     static_assert((std::is_same<decltype(std::feholdexcept(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(std::fesetenv(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(std::feupdateenv(&fenv)), int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index 4be7122e7..ad1f4c423 100644
--- a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -10,8 +10,10 @@
 
 #include <ccomplex>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp b/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
index 0e9a7cefc..bc0e5d814 100644
--- a/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
@@ -26,7 +26,7 @@ UDT<long double> ldt;
 UDT<int> it;
 UDT<unsigned long> uit;
 
-int main()
+int main(int, char**)
 {
     {
         std::real(ft); // expected-error {{no matching function}}
@@ -70,4 +70,6 @@ int main()
         std::proj(it); // expected-error {{no matching function}}
         std::proj(uit); // expected-error {{no matching function}}
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp b/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
index f05c42f25..bbc865a5a 100644
--- a/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
@@ -43,7 +43,7 @@ test()
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -51,4 +51,6 @@ int main()
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp b/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
index 80bd15714..46bf69aad 100644
--- a/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
@@ -54,7 +54,7 @@ test()
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -62,4 +62,6 @@ int main()
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
index 8be97fac2..a05781273 100644
--- a/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
@@ -56,7 +56,7 @@ test()
     test<T, 10>();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -64,4 +64,6 @@ int main()
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp b/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
index a3bf9dd27..69a2eada8 100644
--- a/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
@@ -43,7 +43,7 @@ test()
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -51,4 +51,6 @@ int main()
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp b/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
index 60a5b1957..802b9e773 100644
--- a/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
@@ -78,7 +78,7 @@ test(typename std::enable_if<!std::is_integral<T>::value>::type* = 0, typename s
     test(std::complex<T>(3, 4), std::complex<U>(5, 6));
 }
 
-int main()
+int main(int, char**)
 {
     test<int, float>();
     test<int, double>();
@@ -100,4 +100,6 @@ int main()
 
     test<long double, float>();
     test<long double, double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp b/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
index a9dfeae57..41b82b0d7 100644
--- a/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
@@ -54,7 +54,7 @@ test()
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -62,4 +62,6 @@ int main()
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
index 5d0fa76b3..41e9c8fe2 100644
--- a/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
+++ b/test/std/numerics/complex.number/cmplx.over/real.pass.cpp
@@ -56,7 +56,7 @@ test()
     test<T, 10>();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -64,4 +64,6 @@ int main()
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
index ed944eb04..7d8d701fd 100644
--- a/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::complex_literals;
 
@@ -47,4 +47,6 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
index 0b09858a3..c5e6b2910 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
@@ -13,7 +13,9 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::complex<float> foo  = 1.0if;  // should fail w/conversion operator not found
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
index 25d0d1d44..ba9532a5e 100644
--- a/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
@@ -13,7 +13,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
@@ -37,4 +37,6 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
index 9fbe5572a..0b8d2f9cb 100644
--- a/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
+++ b/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
@@ -13,7 +13,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std;
 
@@ -37,4 +37,6 @@ int main()
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
index 8ab5460a0..d0ccb14f1 100644
--- a/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
@@ -31,7 +31,7 @@ test()
     assert(c.imag() == -4.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float, float>();
     test<float, double>();
@@ -44,4 +44,6 @@ int main()
     test<long double, float>();
     test<long double, double>();
     test<long double, long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
index cb9a778c2..faab37ea4 100644
--- a/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
@@ -28,9 +28,11 @@ test()
     assert(c.imag() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
index b1d1288ae..052c2dcee 100644
--- a/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
@@ -44,9 +44,11 @@ test()
 
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
index 511140c67..63d34b051 100644
--- a/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
@@ -35,9 +35,11 @@ test()
     assert(c.imag() == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
index 11c5c319d..09cde6124 100644
--- a/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
@@ -43,9 +43,11 @@ test()
     assert(c3.imag() == -6);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
index e3d9da7b5..ae5b07157 100644
--- a/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
@@ -31,9 +31,11 @@ test()
     assert(c.imag() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
index d108b8a54..0c86b6750 100644
--- a/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
@@ -43,9 +43,11 @@ test()
     assert(c3.imag() == 6);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
index b417505fa..498724a36 100644
--- a/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
@@ -31,9 +31,11 @@ test()
     assert(c.imag() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
index 1d0469085..fc690072b 100644
--- a/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
@@ -43,9 +43,11 @@ test()
     assert(c3.imag() ==   3.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp b/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
index f32b247c2..6cb95ea66 100644
--- a/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
@@ -35,9 +35,11 @@ test()
     assert(c.imag() == 3);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.members/construct.pass.cpp b/test/std/numerics/complex.number/complex.members/construct.pass.cpp
index 75d9b5d67..fa5e5729f 100644
--- a/test/std/numerics/complex.number/complex.members/construct.pass.cpp
+++ b/test/std/numerics/complex.number/complex.members/construct.pass.cpp
@@ -63,9 +63,11 @@ test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp b/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
index b1b378b56..c4a1ef935 100644
--- a/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
+++ b/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
@@ -56,10 +56,12 @@ test()
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_constexpr<int> ();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
index 44837cc09..5166fa57f 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -149,10 +149,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
index ec9af0d21..e7a1d81cf 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
@@ -32,9 +32,11 @@ test()
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
index 88cee3158..27621f165 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
@@ -52,10 +52,12 @@ test()
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //    test_constexpr<int> ();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
index e08d85fd1..1ec74e703 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
@@ -73,10 +73,12 @@ test()
     test_constexpr<T> ();
     }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int> ();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
index eb93cbe63..999a2c91d 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
@@ -40,9 +40,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
index 0b81ed949..9aea6819c 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
@@ -40,9 +40,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
index 4ad67be2c..319e453a9 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
@@ -54,10 +54,12 @@ test()
     test_constexpr<T> ();
     }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //   test_constexpr<int> ();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
index 43f0f8c5d..69c71cde0 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
@@ -73,10 +73,12 @@ test()
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int> ();
-    }
+    
+  return 0;
+}
diff --git a/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
index 46953f662..5a2fdcfb0 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
@@ -40,9 +40,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
index 7f4a7a2b5..4f9dfb1d4 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
@@ -40,9 +40,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
index ba499e51b..f2203d4db 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -151,10 +151,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp b/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
index 94afd4b86..9fface6b7 100644
--- a/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
@@ -32,9 +32,11 @@ test()
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
index e793c7dc9..01b706dd7 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
@@ -32,9 +32,11 @@ test()
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
index 551fd2574..d5dcc2918 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
@@ -73,10 +73,12 @@ test()
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
index b69389827..006572492 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
@@ -40,9 +40,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
index 352181476..edff47a01 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
@@ -73,10 +73,12 @@ test()
     test_constexpr<T> ();
     }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
index 52ae2a150..d8fc8a6d9 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
@@ -40,9 +40,11 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp b/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
index 1e96a3d9c..a33347db0 100644
--- a/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
@@ -32,9 +32,11 @@ test()
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp b/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
index e6d944f42..4f33b97eb 100644
--- a/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream is("5");
@@ -95,4 +95,6 @@ int main()
         assert(c == std::complex<double>(-5.5, -6.5));
         assert(!is.eof());
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp b/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
index 2e72bd8a5..2f1fa91e8 100644
--- a/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> c(1, 2);
     std::ostringstream os;
     os << c;
     assert(os.str() == "(1,2)");
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp b/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
index c61c8779f..0249240e8 100644
--- a/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
@@ -27,9 +27,11 @@ test()
     assert(c.imag() == -2.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp b/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
index e6d2de6e4..c5c2b6de1 100644
--- a/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
+++ b/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
@@ -27,9 +27,11 @@ test()
     assert(c.imag() == 2.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
index 9681bdb17..f2e64466f 100644
--- a/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp b/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
index db4fb2c4f..72a4f0241 100644
--- a/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
index 09f2b6ae2..751b3b851 100644
--- a/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<long double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp b/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
index 72031e11e..51242310a 100644
--- a/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
+++ b/test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
@@ -17,10 +17,12 @@
 #include <complex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::complex<long double> cd(2.5, 3.5);
     std::complex<double> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
index e2074cbe3..7ed53c62d 100644
--- a/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp b/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
index 66876e0bc..7274a2121 100644
--- a/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
@@ -17,10 +17,12 @@
 #include <complex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::complex<double> cd(2.5, 3.5);
     std::complex<float> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
index 5e56346ec..b191bf6ea 100644
--- a/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<long double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp b/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
index 6e9bc5b3a..3bf7a0376 100644
--- a/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
+++ b/test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
@@ -17,10 +17,12 @@
 #include <complex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::complex<long double> cd(2.5, 3.5);
     std::complex<float> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
index 3b4ce5839..e257db2bd 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
index 5f967668f..b47d945fe 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
index afbea2a0c..97f91ee07 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp b/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
index e6d197365..51e966d4c 100644
--- a/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
+++ b/test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@ int main()
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp b/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
+++ b/test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index 76b280af3..ecb669689 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -129,10 +129,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index b981e1a31..4a22dde02 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -140,10 +140,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index 7d6516aeb..91ec6e9bd 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -108,10 +108,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index c6a6d8bb3..18ac1f17a 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -117,10 +117,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
index f4025ae73..1816e2f99 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -57,10 +57,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index 4f037377e..5e4bb13f5 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -121,10 +121,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index ff069397a..2085a4c85 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -56,10 +56,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index eb6ef8832..e95c2968d 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -106,10 +106,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
index 9442bb084..fc638d135 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -104,10 +104,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
index 98d3cf454..35f0c5c41 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -121,10 +121,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
index 299e037a6..676175507 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -55,10 +55,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
index 848527792..d34ab0c7c 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -60,10 +60,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
index 55120dcd5..7ffdd6136 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -58,10 +58,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
index 81b4b2ca7..e4b5d3d14 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -58,10 +58,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index 2c2b8cbb9..6e33f7054 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -57,10 +57,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index a2668320f..7a9e79898 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -107,10 +107,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
index 007bf2ac3..a0b843302 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -99,10 +99,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
index e7c80a309..b4bc207fc 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -58,10 +58,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index 511cdeefa..1be3a2cd0 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -89,10 +89,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
index 8fa09a7ef..7a518fc37 100644
--- a/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -53,10 +53,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
index 27366ec0e..280ccc8cb 100644
--- a/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -125,10 +125,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
index 7d6472aa6..8c144ffbf 100644
--- a/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
@@ -32,9 +32,11 @@ test()
     test(std::complex<T>(-1, -2), std::complex<T>(-1, 2));
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
index d4bf0d8c1..fe7cb3a96 100644
--- a/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
@@ -23,9 +23,11 @@ test()
     assert(imag(z) == 2.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
index aeb13c80b..fe197ff21 100644
--- a/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -53,10 +53,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
index 3f7c497c2..b7450abed 100644
--- a/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -102,10 +102,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
index 6de4a0af8..238429b55 100644
--- a/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -61,10 +61,12 @@ void test_edges()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp b/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
index a94ba9f14..138785900 100644
--- a/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
+++ b/test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
@@ -23,9 +23,11 @@ test()
     assert(real(z) == 1.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/complex/types.pass.cpp b/test/std/numerics/complex.number/complex/types.pass.cpp
index 3b2f3f7b8..517743071 100644
--- a/test/std/numerics/complex.number/complex/types.pass.cpp
+++ b/test/std/numerics/complex.number/complex/types.pass.cpp
@@ -27,9 +27,11 @@ test()
     static_assert((std::is_same<typename C::value_type, T>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/complex.number/layout.pass.cpp b/test/std/numerics/complex.number/layout.pass.cpp
index a154f5e40..bcb81189a 100644
--- a/test/std/numerics/complex.number/layout.pass.cpp
+++ b/test/std/numerics/complex.number/layout.pass.cpp
@@ -27,9 +27,11 @@ test()
     assert(a[1] == z.imag());
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/numerics/nothing_to_do.pass.cpp b/test/std/numerics/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/nothing_to_do.pass.cpp
+++ b/test/std/numerics/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp b/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp b/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
index 854b5cb35..312425afb 100644
--- a/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
@@ -15,10 +15,12 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::gslice gs;
     assert(gs.start() == 0);
     assert(gs.size().size() == 0);
     assert(gs.stride().size() == 0);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp b/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
index 2faff95c7..682bb83fd 100644
--- a/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
@@ -16,7 +16,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::size_t a1[] = {1, 2, 3};
     std::size_t a2[] = {4, 5, 6};
@@ -34,4 +34,6 @@ int main()
     assert(r[0] == 4);
     assert(r[1] == 5);
     assert(r[2] == 6);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp b/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp b/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
index c03de2343..92c17b8a2 100644
--- a/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
@@ -15,10 +15,12 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::slice s;
     assert(s.start() == 0);
     assert(s.size() == 0);
     assert(s.stride() == 0);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp b/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
index c74f20d5a..72bff9757 100644
--- a/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
@@ -15,10 +15,12 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::slice s(1, 3, 2);
     assert(s.start() == 1);
     assert(s.size() == 3);
     assert(s.stride() == 2);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp b/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp b/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
+++ b/test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/default.fail.cpp b/test/std/numerics/numarray/template.gslice.array/default.fail.cpp
index dbad4eebb..4429367cf 100644
--- a/test/std/numerics/numarray/template.gslice.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::gslice_array<int> gs;
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
index a2f001427..3a916257b 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -77,4 +77,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
index 147c6e29d..e1aca3b7c 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
index fb1f3b5ee..9c82a6f94 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
index 4aa5f0245..bfe8ab288 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
index 9631d67b0..ec54bc4bb 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
index d74ceaf96..63ad3a777 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
index 9ed9fcd95..b22fd3015 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
index f6c1007e8..0b068935f 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
index 92987929e..912e48aca 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
index e61715849..2c8598f7b 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
index 6b5075e05..8b1271b04 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
index 285e44cde..9a981ece8 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
index d3e987078..c7c092580 100644
--- a/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -70,4 +70,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.gslice.array/types.pass.cpp b/test/std/numerics/numarray/template.gslice.array/types.pass.cpp
index 4fcc77177..9263c0e05 100644
--- a/test/std/numerics/numarray/template.gslice.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.gslice.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::gslice_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/default.fail.cpp b/test/std/numerics/numarray/template.indirect.array/default.fail.cpp
index 203a91726..988cdad90 100644
--- a/test/std/numerics/numarray/template.indirect.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::indirect_array<int> ia;
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
index 5b27d5e0a..c19152bb9 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -76,4 +76,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
index f3f0a49a4..0bc4b5817 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
index 297b9ed85..3ed95f9cb 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
index 1dcb9c0b1..00fd2f18d 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
index 1112bca9f..1a9ca265a 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
index 061735a26..bad0b950e 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
index d64ff33f1..7e78f0a8f 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
index 11240333c..ba32accc6 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
index 160bb8059..deff80cc3 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
index fbebc1a25..d2ac73954 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
index 1d4a5bf14..d94422c09 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
index 0a6434454..06e066827 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
index d49f2a0f6..e327d2630 100644
--- a/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -70,4 +70,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.indirect.array/types.pass.cpp b/test/std/numerics/numarray/template.indirect.array/types.pass.cpp
index 6cc9988aa..5d06c5baf 100644
--- a/test/std/numerics/numarray/template.indirect.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.indirect.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::indirect_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/default.fail.cpp b/test/std/numerics/numarray/template.mask.array/default.fail.cpp
index 5bec2dcad..f22298bf9 100644
--- a/test/std/numerics/numarray/template.mask.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.mask.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::mask_array<int> s;
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
index d16040556..22ce22ad6 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
@@ -62,4 +62,6 @@ int main()
     std::mask_array<int> const & r = (m1 = m2);
     assert(&r == &m1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
index e7e0d3740..e364c442f 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
index 084a0d11b..e8f0958b5 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
index e797343b6..ab2937986 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
index dc7bbb2f1..cd67632ef 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
index 302cdcc3e..7cf8b585d 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
index cfe282203..537bf40d8 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
index 2fdfe0de2..d0297b831 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
index aaf6f2d43..eee4c1d46 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
index 15d745e02..b65c19f99 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
index 7b09a0ec4..40fddd123 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
index 5487ea024..a04b6da27 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
index 63558d8d5..bb4fd8591 100644
--- a/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -41,4 +41,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.mask.array/types.pass.cpp b/test/std/numerics/numarray/template.mask.array/types.pass.cpp
index 6848c655b..1d4acea6f 100644
--- a/test/std/numerics/numarray/template.mask.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.mask.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::mask_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/default.fail.cpp b/test/std/numerics/numarray/template.slice.array/default.fail.cpp
index 59f5fdf0e..90b1845ba 100644
--- a/test/std/numerics/numarray/template.slice.array/default.fail.cpp
+++ b/test/std/numerics/numarray/template.slice.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::slice_array<int> s;
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
index 40dc0be71..9683c7dfb 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
@@ -50,4 +50,6 @@ int main()
     std::slice_array<int> const & s3 = (s1 = s2);
     assert(&s1 == &s3);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
index 7ea08cfae..88a5b44ab 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] == -5);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
index 5934c2015..0433877e7 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] ==  8);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
index 3af46538b..90bbe4ef3 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] ==  5);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
index 508ebbbd8..ae1383b84 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] == -2);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
index 7b3919e49..89c1acfb3 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] ==  3);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
index ffcd85424..b7c6b1353 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] == -65);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
index b40544234..0f37579e8 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
index fcf51bb18..547a8cd27 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] == 416);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
index 4c79b559b..99c4ef943 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] ==  0);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
index aae003cf3..db513bc96 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] == 18);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
index afebc8820..4ecba4723 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] ==  8);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp b/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
index ed1b219a6..ab2156b46 100644
--- a/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a1, sizeof(a1)/sizeof(a1[0]));
@@ -37,4 +37,6 @@ int main()
     assert(v1[13] == 20);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.slice.array/types.pass.cpp b/test/std/numerics/numarray/template.slice.array/types.pass.cpp
index 0d1989a48..fccde7edb 100644
--- a/test/std/numerics/numarray/template.slice.array/types.pass.cpp
+++ b/test/std/numerics/numarray/template.slice.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::slice_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/types.pass.cpp b/test/std/numerics/numarray/template.valarray/types.pass.cpp
index 301192ef8..f37ba0f77 100644
--- a/test/std/numerics/numarray/template.valarray/types.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/types.pass.cpp
@@ -18,8 +18,10 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::valarray<int>::value_type, int>::value), "");
     static_assert((std::is_same<std::valarray<double>::value_type, double>::value), "");
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
index dc90dbef9..d92154130 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
             assert(v[i] == static_cast<int>(i));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
index a4c81440e..a0174ccb3 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -27,4 +27,6 @@ int main()
             assert(v[i] == a[i]);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
index 24f6cc54b..777d922a4 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
@@ -31,7 +31,7 @@ bool operator==(const S& lhs, const S& rhs)
     return lhs.x_ == rhs.x_;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -82,4 +82,6 @@ int main()
             assert(v2[i] == v[i]);
         assert(!S::default_ctor_called);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
index 625cf17a8..df5ae9162 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -54,4 +54,6 @@ int main()
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
index 3c351d0b3..f8b5243b9 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -54,4 +54,6 @@ int main()
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
index 4f9b60db6..1f9e5a51f 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
@@ -33,7 +33,7 @@ bool operator==(const S& lhs, const S& rhs)
     return lhs.x_ == rhs.x_;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -80,4 +80,6 @@ int main()
             assert(v2[i] == a[i]);
         assert(!S::default_ctor_called);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
index 592e306e7..aeb95a10b 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -31,4 +31,6 @@ int main()
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
index 263c093b9..522c0a2a3 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -60,4 +60,6 @@ int main()
                 assert(v2[i][j] == a[i][j]);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
index 5ccfa2e08..68b0e37d4 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a, sizeof(a)/sizeof(a[0]));
@@ -27,4 +27,6 @@ int main()
     assert(v[2] == 7);
     assert(v[3] == 10);
     assert(v[4] == 13);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
index c722f8b1e..3adb1465c 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -28,4 +28,6 @@ int main()
         for (std::size_t i = 0; i < v.size(); ++i)
             assert(v[i] == 7);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
index d6f7c57d5..60b307153 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
index 6c37d2bc1..287372150 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
index a5cccdc86..fdb9975d5 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
index bff87ab95..a309767ff 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
index e574de21f..a8ef9152b 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
index 0dee79df7..263ac820a 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
index 5dc7ca5ce..79cfeb0c4 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v2[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
index 0e306cefc..b0ea0a298 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
index 97e3b9b99..df962a044 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
index ba44c578d..1be8942ab 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
index 67ed8bc5c..3700e5c47 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
index 730ac7f15..c8c5d1ef9 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
index 91ea80ed2..f642ce431 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
index abbb0023c..8cba6b4da 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
index f5fc5c724..d50971b39 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
index 00f5e2560..670599afd 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
index 00ac963b7..f7e3da5bf 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
index a039f9f8c..963279968 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
index f9d8ba3b5..bf0805511 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
index 02c139824..0a3d3200f 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
index a97a25047..8a9c6baae 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -52,4 +52,6 @@ int main()
                 assert(v2[i][j] == v[i][j]);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
index ff4a7a254..b56039802 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
@@ -22,7 +22,7 @@ struct S {
 
 bool S::ctor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         std::valarray<int> v;
@@ -45,4 +45,6 @@ int main()
         assert(v.size() == 0);
         assert(!S::ctor_called);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
index 7e061f50a..fdab3e3e8 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@ int main()
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
index e525b2a4f..3a62b0a54 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@ int main()
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
index bd47c5798..1f5986eda 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@ int main()
         for (unsigned i = 0; i < N; ++i)
             assert(v[i] == a[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
index e9deea94a..4559c36e7 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -30,4 +30,6 @@ int main()
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
index 010649a92..0ef6f3cee 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -58,4 +58,6 @@ int main()
                 assert(v2[i][j] == a[i][j]);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
index 84d51b035..a0b4a31ae 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -49,4 +49,6 @@ int main()
                 assert(v[i][j] == a[i][j]);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
index 7e539d9c2..95417e58a 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
@@ -24,7 +24,7 @@ struct S {
 
 size_t S::cnt_dtor = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::valarray<int> v(100);
@@ -51,4 +51,6 @@ int main()
             assert(v[i].x == 1);
     }
     assert(S::cnt_dtor == 100);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
index c5667671f..332a61715 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a, sizeof(a)/sizeof(a[0]));
@@ -26,4 +26,6 @@ int main()
     assert(v[2] == 7);
     assert(v[3] == 10);
     assert(v[4] == 13);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
index 6e43de782..03e4add46 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::valarray<int> v(5, 100);
@@ -35,4 +35,6 @@ int main()
         for (int i = 0; i < 100; ++i)
             assert(v[i].size() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
index 7d4d07923..65277870a 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
@@ -19,7 +19,7 @@ typedef int T;
 
 T f(const T& t) {return t + 5;}
 
-int main()
+int main(int, char**)
 {
     {
         T a1[] = {1, 2, 3, 4,  5,  6,  7,  8,  9, 10};
@@ -47,4 +47,6 @@ int main()
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
index d43810062..fd100b5e5 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
@@ -19,7 +19,7 @@ typedef int T;
 
 T f(T t) {return t + 5;}
 
-int main()
+int main(int, char**)
 {
     {
         T a1[] = {1, 2, 3, 4,  5,  6,  7,  8,  9, 10};
@@ -47,4 +47,6 @@ int main()
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
index 1aa6a3e9a..14ca081a1 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -123,4 +123,6 @@ int main()
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
index cc80ea8e0..bdd84c118 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -36,4 +36,6 @@ int main()
         std::valarray<T> v1(a1, N1);
         assert((2*v1).max() == 8.0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
index 37d8f3a31..ca04a9308 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -36,4 +36,6 @@ int main()
         std::valarray<T> v1(a1, N1);
         assert((2*v1).min() == -6.0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
index 82dd0bd38..e92e7420b 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -38,4 +38,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
index 2be57bff3..1a7628eb3 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -123,4 +123,6 @@ int main()
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
index 3498cc59c..f79062723 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@ int main()
         std::valarray<T> v1;
         assert(v1.size() == N1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
index b1c530aa4..084f00fb9 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -24,4 +24,6 @@ int main()
         std::valarray<T> v1(a1, N1);
         assert(v1.sum() == 16.5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
index 23cf807af..12a7d8fd8 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -82,4 +82,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == v1_save[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
index 32e6b5561..d84309f22 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@ int main()
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
index 12caa6118..ac6971878 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@ int main()
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
index d210e5120..7e5ef1546 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@ int main()
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
index 053e9267e..82a5f1448 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -54,4 +54,6 @@ int main()
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
index 3eaafee7e..d689ce923 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a1, sizeof(a1)/sizeof(a1[0]));
@@ -26,4 +26,6 @@ int main()
     assert(v2[2] ==  7);
     assert(v2[3] == 10);
     assert(v2[4] == 13);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
index d4cb64cf9..a6c7cb7e8 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@ int main()
     assert(v1[13] == -5);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
index 77e86ac73..13cafbccb 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -30,4 +30,6 @@ int main()
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
index 6ea9e1849..34b4cfdb5 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -31,4 +31,6 @@ int main()
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
index 8bb23c0b4..7f31355d0 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -52,4 +52,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == ~(2*v[i]));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
index 2827488d2..a89b24d23 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -62,4 +62,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == -2*v[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
index 64e902146..3975510fb 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -38,4 +38,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == !(2 * v[i]));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp b/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
index 113bb12e9..b1f7f313f 100644
--- a/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
+++ b/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -62,4 +62,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == +2*v[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
index d195f1d24..3be9074db 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
index 4e083bd15..4f1bf8ad6 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
index 89fdd065a..05990124e 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
index 4b76423ae..50c6a1484 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
index babecfe99..f5e0b2727 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
index 29316e4c7..dde6955bb 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
index af78964ca..f1df168b3 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
index e6760c230..0ea4f0c1d 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
index 1d984be79..f2131d10e 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
index 948688ba3..22d82f4b5 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
index 101b32d53..f498e7af5 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
index dc2ecc0f8..fbd407ce2 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
index c01d33a2b..f305243d5 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
index 328afb2a4..90fa4b4fd 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
index e5ca45963..295dd6bdc 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
index c65a7b2a6..19a410e4f 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
index 46b7fbb55..2aef9c1a1 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
index 97b7791de..ba598f62d 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
index 90f9d756c..e71fa1056 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
index 5136d3fd9..3945c1bf4 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
index 697b46db8..932763452 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
index 4194c191a..9422d6be8 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
index 4aabb8a94..8a68f30ca 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
index cccdca18c..519fd2b3b 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
index c15b794ce..bc5e7329c 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
index 155ea25b5..330f5e0a7 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
index b825ad54e..4fa8bb2d2 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
index 5e07f5d44..fd4fb084c 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
index bc22ebadd..c5082f553 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
index 14574a10d..377f03ed3 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
index 3e0951b6e..3f3ede056 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
index 75bce73a2..de5808e57 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
index a6cd5e836..c73ec1e54 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
index 3b43c1097..187126fc8 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
index 1bd1fa0e8..01c04a62c 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
index 5fb05f60a..b0db6a0d1 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
index 6f7678fc7..c8de6208a 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
index f26e94694..cf568b530 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
index 2c795aae3..c66a60e06 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
index 03468763f..351b662be 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
index 970f8d8d5..f895b0783 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
index ad30ae425..a54b77025 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
index 86e5553a8..c8812f3fd 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
index d520a21b9..03caf34a6 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
index 2055f7554..5026b73d4 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
index 0eb137ca0..59943f912 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
index d7d6b7d8b..9ced47571 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
index 34419bdec..770d5a96f 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
index 4daca5332..1892a7071 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
index add76d16c..3cdb89739 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
index a35038051..49ffeda05 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
index ef2b16509..f62cb4f8c 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
index 60f14f2bb..df73f85e3 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@ int main()
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
index 0d9a3124e..3798acc67 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
index 478350837..2200ddfe0 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -84,4 +84,6 @@ int main()
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == v1_save[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
index ff5c7d89a..d721c8442 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -31,4 +31,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
index bee16abd7..18b5bcb5b 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
index 4cecd8cac..9401200e5 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
index 7e81821dd..fcbd63b83 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -50,4 +50,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
index 3ab737577..59928d447 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
index 07e7894ae..ed42627d1 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
index 567f568a9..7176b9343 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
index 182b8bc3a..bc58e4af2 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
index fb0965bb3..b453edd08 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
index 3c19e3edf..8e95f8704 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
index 70ba211a8..39514ed68 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
index 3e616a062..050d58fa5 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
index 096cd5d32..93b8a14cb 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -50,4 +50,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
index 902c9f321..62c140c04 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
index 394497823..0c8a76b6d 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
index 2cf38b88b..92d6f4492 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
index fa591d0c6..190c212ac 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
index eb40e61b3..805bde633 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
index 6395ee550..4f5b69d08 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
index 10e0a22be..c63696a83 100644
--- a/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
+++ b/test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
@@ -31,7 +31,7 @@ bool is_about(double x, double y, int p)
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@ int main()
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp b/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
index db39ab4a1..35e5e4206 100644
--- a/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
@@ -17,7 +17,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -26,4 +26,6 @@ int main()
         const std::valarray<T> v(a, N);
         assert(v[0] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp b/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
index fb4013dee..e0d8e71da 100644
--- a/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
@@ -17,7 +17,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -27,4 +27,6 @@ int main()
         *begin(v) = 10;
         assert(v[0] == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.range/end_const.pass.cpp b/test/std/numerics/numarray/valarray.range/end_const.pass.cpp
index 113216ad0..d1424d3f0 100644
--- a/test/std/numerics/numarray/valarray.range/end_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/end_const.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -28,4 +28,6 @@ int main()
         assert(v[v.size()-1] == 5);
         assert(static_cast<std::size_t>(end(v) - begin(v)) == v.size());
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp b/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
index c5d54729a..5e1cbd4a8 100644
--- a/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
+++ b/test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@ int main()
         assert(v[v.size()-1] == 10);
         assert(static_cast<std::size_t>(end(v) - begin(v)) == v.size());
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp b/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp b/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
index 2a14a7d8e..80a048d07 100644
--- a/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
+++ b/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
@@ -42,11 +42,13 @@ test()
     test(Iter(ia), Iter(ia+sa), 10, 31);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*> >();
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp b/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
index a6dc04b2d..c7a55b971 100644
--- a/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
@@ -44,11 +44,13 @@ test()
     test(Iter(ia), Iter(ia+sa), 10, 7200);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*> >();
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
index ac0b17741..3e043e5cb 100644
--- a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
+++ b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
@@ -75,7 +75,7 @@ public:
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -112,4 +112,6 @@ int main()
     Y y[3] = {Y(1), Y(2), Y(3)};
     std::adjacent_difference(x, x+3, y);
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
index 967ec2ea3..9a10105d0 100644
--- a/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
@@ -78,7 +78,7 @@ public:
 #endif
 
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -115,4 +115,6 @@ int main()
     Y y[3] = {Y(1), Y(2), Y(3)};
     std::adjacent_difference(x, x+3, y, std::minus<X>());
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
index 5568e0d80..447ceb61e 100644
--- a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
+++ b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
@@ -85,7 +85,7 @@ void basic_tests()
 
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -96,4 +96,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
index 78c8325e2..46cb0800b 100644
--- a/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
@@ -59,7 +59,7 @@ test()
         }
 }
 
-int main()
+int main(int, char**)
 {
 //  All the iterator categories
     test<input_iterator        <const int*> >();
@@ -85,4 +85,6 @@ int main()
         assert(res[i] == j);
     }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
index b02ce5408..0ab019c5e 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
@@ -90,7 +90,7 @@ void basic_tests()
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -101,4 +101,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
index 07561175b..88633ac84 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -97,7 +97,7 @@ void basic_tests()
 }
 
 
-int main()
+int main(int, char**)
 {
 
     basic_tests();
@@ -110,4 +110,6 @@ int main()
 //     test<const int*>();
 //     test<      int*>();
 
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
index 06a187454..c6e691aee 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
@@ -113,7 +113,7 @@ void basic_tests()
 }
 
 
-int main()
+int main(int, char**)
 {
 
     basic_tests();
@@ -126,4 +126,6 @@ int main()
     test<const int*>();
     test<      int*>();
 
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp b/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
index fec9182b1..fa5c1e834 100644
--- a/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
+++ b/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
@@ -47,7 +47,7 @@ test()
     test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 66);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -78,4 +78,6 @@ int main()
     test<const int*, bidirectional_iterator<const int*> >();
     test<const int*, random_access_iterator<const int*> >();
     test<const int*, const int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp b/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
index d0d152db1..e42e3cea9 100644
--- a/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
+++ b/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
@@ -50,7 +50,7 @@ test()
     test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 1176490);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -81,4 +81,6 @@ int main()
     test<const int*, bidirectional_iterator<const int*> >();
     test<const int*, random_access_iterator<const int*> >();
     test<const int*, const int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp b/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
index 312867425..2c1c08e8b 100644
--- a/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
@@ -28,10 +28,12 @@ test()
         assert(ia[i] == ir[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
index 70173d08b..1c56a6707 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(false, 4);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
index 106434d97..9390e50f1 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(2, true);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
index 138bdd6db..2aceb285b 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd<volatile bool, int>(false, 4);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
index 8e8e75593..234a4d7ce 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd<int, const bool>(2, true);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
index 7bcf29d13..1aeb5249f 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(2.0, 4);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
index aceb0ff63..89079181b 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(4, 6.0);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
index 83a90b984..bba3780bd 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
@@ -91,7 +91,7 @@ constexpr bool do_test(int = 0)
     return accumulate;
 }
 
-int main()
+int main(int, char**)
 {
     auto non_cce = std::rand(); // a value that can't possibly be constexpr
 
@@ -141,4 +141,6 @@ int main()
     static_assert(std::is_same_v<decltype(res), std::int64_t>, "");
     assert(res == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
index 43fc1f5bf..ab199d7a8 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(false, 4);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
index b9e1128dc..68bfd1d21 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(2, true);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
index 763b65f99..4f4042267 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm<volatile bool, int>(false, 4);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
index dd7c43a41..2cdbcefdc 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm<int, const bool>(2, true);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
index 81f25887e..968034b02 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(2.0, 4);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
index ef039ca79..ed2813f6a 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(4, 6.0);
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
index a42303776..8a0567061 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
@@ -90,7 +90,7 @@ constexpr bool do_test(int = 0)
     return accumulate;
 }
 
-int main()
+int main(int, char**)
 {
     auto non_cce = std::rand(); // a value that can't possibly be constexpr
 
@@ -141,4 +141,6 @@ int main()
     static_assert(std::is_same_v<decltype(res1), std::int64_t>, "");
     assert(res1 == 1324997410816LL);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp b/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
index 90a74e22f..4ea410712 100644
--- a/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
+++ b/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
@@ -35,7 +35,7 @@ test()
         assert(ib[i] == ir[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -66,4 +66,6 @@ int main()
     test<const int*, bidirectional_iterator<int*> >();
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp b/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
index eadcd5a3a..ab51b5b5b 100644
--- a/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
@@ -37,7 +37,7 @@ test()
         assert(ib[i] == ir[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -68,4 +68,6 @@ int main()
     test<const int*, bidirectional_iterator<int*> >();
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
index ebdaaac91..031a12d29 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
@@ -46,7 +46,7 @@ void test_return_type()
     static_assert( std::is_same_v<T, decltype(std::reduce(p, p))> );
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char>();
     test_return_type<int>();
@@ -59,4 +59,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
index 22b5a7239..19c6b7d5f 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
@@ -48,7 +48,7 @@ void test_return_type()
     static_assert( std::is_same_v<Init, decltype(std::reduce(p, p, Init{}))> );
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -63,4 +63,6 @@ int main()
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
index 7c2692171..adcf92879 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
@@ -48,7 +48,7 @@ void test_return_type()
     static_assert( std::is_same_v<Init, decltype(std::reduce(p, p, Init{}, std::plus<>()))>, "" );
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -70,4 +70,6 @@ int main()
     unsigned res = std::reduce(v.begin(), v.end(), 1U, std::multiplies<>());
     assert(res == 40320);       // 8! will not fit into a char
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
index dc9412ec1..528802cb4 100644
--- a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -139,7 +139,7 @@ void basic_tests()
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -150,4 +150,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
index 412c4b292..f7a321317 100644
--- a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
@@ -113,7 +113,7 @@ void basic_tests()
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -124,4 +124,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
index d29131bd1..56e5bc6e7 100644
--- a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
@@ -139,7 +139,7 @@ void basic_tests()
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -150,4 +150,6 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
index 541fbb76f..38071531b 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
@@ -91,7 +91,7 @@ void test_move_only_types()
         [](const MoveOnly& target) { return MoveOnly{target.get() * 10}; }).get());
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -117,4 +117,6 @@ int main()
     }
 
     test_move_only_types();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
index 8f846a893..d74267c71 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
@@ -65,7 +65,7 @@ void test_move_only_types()
         std::transform_reduce(std::begin(ia), std::end(ia), std::begin(ib), MoveOnly{0}).get());
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -103,4 +103,6 @@ int main()
     test<      int*,       unsigned int *>();
 
     test_move_only_types();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
index 586e7b180..27bad12ce 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
@@ -69,7 +69,7 @@ void test_move_only_types()
         [](const MoveOnly& lhs, const MoveOnly& rhs) { return MoveOnly{lhs.get() * rhs.get()}; }).get());
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -107,4 +107,6 @@ int main()
     test<      int*,       unsigned int *>();
 
     test_move_only_types();
+
+  return 0;
 }
diff --git a/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp b/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/numerics.general/nothing_to_do.pass.cpp b/test/std/numerics/numerics.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/numerics.general/nothing_to_do.pass.cpp
+++ b/test/std/numerics/numerics.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/nothing_to_do.pass.cpp b/test/std/numerics/rand/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
index dbc038fc5..5deb1d50c 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
@@ -48,8 +48,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
index 78bc6b297..443f4f8d8 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
@@ -46,8 +46,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
index a0833fb4a..57f2bcc76 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::ranlux24_base Engine;
@@ -25,4 +25,6 @@ int main()
         Adaptor a(e);
         assert(a.base() == e);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
index 5df116384..ade8e8d81 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::ranlux24_base Engine;
@@ -26,4 +26,6 @@ int main()
         Adaptor a(std::move(e0));
         assert(a.base() == e);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
index 4022917b9..6fe094763 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
@@ -43,8 +43,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
index c56bf4503..fe2d9fea3 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
@@ -47,8 +47,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
index 703dd3d7c..32af7046f 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
@@ -34,8 +34,10 @@ test2()
     assert(e1() == 23459059301164ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
index ca675b9ff..a6f4d64e3 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
@@ -44,8 +44,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
index 33e0f73ee..75f07aeca 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
@@ -34,8 +34,10 @@ test2()
     assert(e() == 276846226770426ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
index ebfddfc37..a9fbd7963 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
@@ -55,8 +55,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
index 7df00d8e6..a18e09bd1 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
@@ -34,8 +34,10 @@ test2()
         std::uint_fast64_t>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
index 0dff0790c..bfa93767e 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
@@ -42,8 +42,10 @@ test2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
index 738b306b2..5506cffa1 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
@@ -40,8 +40,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
index fef9ab497..423a629e7 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
@@ -64,8 +64,10 @@ test2()
     where(E::used_block);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
index def8387e1..79205aacc 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
@@ -48,8 +48,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
index 179ffaf46..22e68626e 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
@@ -46,8 +46,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
index c858600cc..65fad3e2f 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::mt19937 Engine;
@@ -25,4 +25,6 @@ int main()
         Adaptor a(e);
         assert(a.base() == e);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
index 1ecf36c43..f3b1d526f 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::mt19937 Engine;
@@ -26,4 +26,6 @@ int main()
         Adaptor a(std::move(e0));
         assert(a.base() == e);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
index 9fa1383a8..84817b16e 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
@@ -43,8 +43,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
index a179753a8..d2792f98f 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
@@ -47,8 +47,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
index 422aaf936..d7e72e3e7 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
@@ -34,8 +34,10 @@ test2()
     assert(e1() == 18223106896348967647ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
index fa735c09e..8f2921923 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
@@ -44,8 +44,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
index 036dc1fbc..9d60eaba3 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
@@ -129,7 +129,7 @@ test8()
     assert(e() == 16470362623952407241ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -139,4 +139,6 @@ int main()
     test6();
     test7();
     test8();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
index 0362cbfc2..b1a73193c 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
@@ -55,8 +55,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
index ee47a38b9..1b6fb87e3 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
@@ -77,8 +77,10 @@ test2()
         unsigned long long>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
index 204c89739..8225044d7 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
@@ -42,8 +42,10 @@ test2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
index 5c1c34e72..04374d000 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
@@ -40,8 +40,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
index 10d9f4d75..be25ad1e2 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
@@ -51,8 +51,10 @@ test2()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
index d3518432c..da08f58ed 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
@@ -32,7 +32,9 @@ test1()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
index 7c4930879..5788371c3 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
@@ -31,7 +31,9 @@ test1()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
index 4bd805262..0cc29d496 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::minstd_rand0 Engine;
@@ -29,4 +29,6 @@ int main()
 
         assert(a.base() == e);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
index 6daa356a7..35474e6a0 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::minstd_rand0 Engine;
@@ -30,4 +30,6 @@ int main()
 
         assert(a.base() == e);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
index ba0350fc5..5ca51e151 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
@@ -69,7 +69,9 @@ test1()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
index 3d3c06db2..136e7fe87 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
@@ -72,7 +72,9 @@ test1()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
index 438c60790..fff5cee2d 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(e1() == 152607844u);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
index 3e98bf554..1b86048c2 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
@@ -30,7 +30,9 @@ test1()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
index fa7056ca9..4eecfea81 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
@@ -86,9 +86,11 @@ test3()
     assert(e() == 500);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
index 5d7a49a5f..5d80b3afc 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
@@ -41,7 +41,9 @@ test1()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
index 5ba0b5ed2..bcb08557c 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
@@ -77,8 +77,10 @@ test2()
         unsigned long long>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
index 0d71f27e2..24ccfbbf8 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
@@ -29,7 +29,9 @@ test1()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
index 0a5d386b1..8dfbcb00e 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
@@ -28,7 +28,9 @@ test1()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
index 8f9e52442..d98fdf58a 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
@@ -44,7 +44,9 @@ test1()
     where(E::table_size);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.device/ctor.pass.cpp b/test/std/numerics/rand/rand.device/ctor.pass.cpp
index c9838f681..24e372795 100644
--- a/test/std/numerics/rand/rand.device/ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.device/ctor.pass.cpp
@@ -62,7 +62,7 @@ void check_random_device_invalid(const std::string &token) {
 }
 
 
-int main() {
+int main(int, char**) {
   {
     std::random_device r;
   }
@@ -99,4 +99,6 @@ int main() {
     std::random_device r;
   }
 #endif // !defined(_WIN32)
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.device/entropy.pass.cpp b/test/std/numerics/rand/rand.device/entropy.pass.cpp
index 381971377..539c238ba 100644
--- a/test/std/numerics/rand/rand.device/entropy.pass.cpp
+++ b/test/std/numerics/rand/rand.device/entropy.pass.cpp
@@ -15,9 +15,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::random_device r;
     double e = r.entropy();
     ((void)e); // Prevent unused warning
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.device/eval.pass.cpp b/test/std/numerics/rand/rand.device/eval.pass.cpp
index b5b8aa11f..4b68282f7 100644
--- a/test/std/numerics/rand/rand.device/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.device/eval.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::random_device r;
@@ -45,4 +45,6 @@ int main()
     {
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
index bbd200d21..5ed93470d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
@@ -26,7 +26,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
index bf4291cec..e3d866ad4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
@@ -24,7 +24,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
index 1d9a22d1e..a8f76bb23 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -32,4 +32,6 @@ int main()
         D d(0.75);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
index 5543f4073..a568cb2b7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -24,4 +24,6 @@ int main()
         D d(p);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
index faa683d4d..24babc118 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -32,4 +32,6 @@ int main()
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
index a16d52475..e28c39099 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
@@ -26,7 +26,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -100,4 +100,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
index 6d83410d8..bf1d11743 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
@@ -26,7 +26,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -104,4 +104,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
index d24316d87..0e960d6ac 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -24,4 +24,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
index 5107e9006..7c7829796 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
@@ -24,7 +24,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -36,4 +36,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
index acb1ada86..6f4ac7e3d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
@@ -15,11 +15,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
         D d(.25);
         assert(d.max() == true);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
index 626f014b8..8c369dbf8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
@@ -15,11 +15,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
         D d(.5);
         assert(d.min() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
index f8ea5be59..b4fcd04ec 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -26,4 +26,6 @@ int main()
         p = p0;
         assert(p.p() == .7);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
index 91a8bacb7..96ddd4bc4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -25,4 +25,6 @@ int main()
         param_type p = p0;
         assert(p.p() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
index cf1b7d391..612e6c686 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -30,4 +30,6 @@ int main()
         param_type p(0.25);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
index b41a8f778..cde5611ec 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -32,4 +32,6 @@ int main()
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
index a8d6ba15f..e1d9532f0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -23,4 +23,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
index 55af45597..03e3d8a8c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -25,4 +25,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
index 0be93b4b0..539b809b0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
@@ -15,11 +15,13 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, bool>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
index 746a35fb5..e997198ad 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
index f66192938..2c2b65c94 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
index f9ff59cd4..26a6e3a66 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.t() == 3);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
index 569ec41c3..fa69b9123 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.t() == 5);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
index b6c8aeb4a..dbe086ad4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -39,4 +39,6 @@ int main()
         D d2(4, .25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
index 06f16c257..fea71ccb8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
@@ -506,7 +506,7 @@ test11()
 //    assert(kurtosis == x_kurtosis);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -519,4 +519,6 @@ int main()
     test9();
     test10();
     test11();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
index 78a9e6e3b..cd4d00678 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -156,4 +156,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.04);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.3);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
index 304a6b61a..a3ba48f55 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
index 90eeb394c..cb272152a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
index 946e7ed93..c8ca662b6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
         D d(4, .25);
         assert(d.max() == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
index c6ac01110..ce793f67b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
         D d(4, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
index 24250bbce..069d6e440 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.t() == 6);
         assert(p.p() == .7);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
index 9445502ed..f2b78e6d8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.t() == 10);
         assert(p.p() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
index 2a7f92843..8ba09a681 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.t() == 10);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
index 0e705adcf..0ba4381ad 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(3, 0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
index 4e95286f3..ba94d412a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
index 66f1d875d..ec82a93ff 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
index 60f811499..c52681a13 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
index 99d7a6dc1..ae49feb3e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
index ea83185e5..73ff6d68f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
index f099589c8..1d4388e4d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         D d(0.75);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
index f682fb71c..3bcebc36f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
index aa358fe74..47ea0f282 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
index 4addb5e15..46ec88121 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
@@ -286,7 +286,7 @@ test6()
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -294,4 +294,6 @@ int main()
     test4();
     test5();
     test6();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
index a3194c4d1..825fa3f5c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -156,4 +156,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
index 2ef240620..35679a862 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
index fb419b468..36de49f78 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
index 00a3780ed..9e785da2e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
         D d(.25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
index ab9e964f0..63f69f25e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
index 0b6033d39..c88af2d68 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         p = p0;
         assert(p.p() == .7);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
index 92f917767..117b98bc1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         param_type p = p0;
         assert(p.p() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
index 75a9b436d..717102285 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -31,4 +31,6 @@ int main()
         param_type p(0.25);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
index 973491fd8..a741f06f6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
index bb80250a1..2f9efc268 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
index e66f9ace4..74d49d5d8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
index 528996f50..a62b66134 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
index 8b6d1e5a5..20f7f9ffd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
index 68c7703b2..73ee12e43 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
index 3b18e8068..0b9418b7c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.k() == 3);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
index 51b875da9..485a3ae98 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.k() == 5);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
index 7fa43ae9a..b93084e47 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -39,4 +39,6 @@ int main()
         D d2(4, .25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
index 039403eea..4a8f78842 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
@@ -284,7 +284,7 @@ test6()
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -292,4 +292,6 @@ int main()
     test4();
     test5();
     test6();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
index d1f6b6258..b99f6fb07 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -156,4 +156,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
index 0cfe69f0e..63fe38043 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
index cb5ca473f..a26f19906 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
index c5c1cc106..3bc54a4be 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
         D d(4, .25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
index 2dfa797cc..b2354d77c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
         D d(4, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
index d2e948771..7968b01e8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.k() == 6);
         assert(p.p() == .7);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
index ded919569..b16818b26 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.k() == 10);
         assert(p.p() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
index 0fc228a32..ad7908d31 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.k() == 10);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
index d65fa544f..793b4361c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(3, 0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
index 0ac9230ce..c0164edc8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
index d785330a4..8971be5ee 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
index 6d2b75585..ea177377a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
index 66d5a7ade..dfe8785ff 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
index 3d7db5423..85511d161 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
index eb4068c4b..f452b6e0b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
index aedfbb5d3..3a8ed3cc9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.a() == 0.25);
         assert(d.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
index e4e296356..bc42b94f9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
index f578164bd..2b63645ae 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
@@ -26,7 +26,7 @@ f(double x, double a, double b)
     return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -73,4 +73,6 @@ int main()
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
index 450e19225..56921fe0f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
@@ -26,7 +26,7 @@ f(double x, double a, double b)
     return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -79,4 +79,6 @@ int main()
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
index 635d116eb..c3c88b8d7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
index 73a7e11ae..db50cfd5c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
index bfde51747..963e8ed37 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
index 2e2ba7db8..59044b8e2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
index c2a7a04dc..04d94e74d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.a() == .75);
         assert(p.b() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
index 0ee42ef64..88739df68 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.a() == 10);
         assert(p.b() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
index 3c4467068..8563bafbb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.a() == 10);
         assert(p.b() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
index 12ce7de78..97553701e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
index 327d1e7d6..ca0539c41 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
index 9b5b4af16..ba66ec16a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
index b88e6328a..09f79da51 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
index cd25b1929..75242c2b9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
index c7881c686..3eeba40d0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
index 77279803e..a778b2fac 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         D d(14.5);
         assert(d.n() == 14.5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
index 7cf8c7dfb..922e44f61 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.n() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
index f26b78a79..8b9ad4574 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
index 81f3359eb..b080886a8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -148,4 +148,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
index 09a33327f..86ac86ed3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -154,4 +154,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
index 0173fb3f4..55fda0872 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
index fde2fecf0..101786131 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
index d5b337f2c..19ab87ca9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
index 54d800559..af5b45617 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
index fa243f22c..0b13690f2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         p = p0;
         assert(p.n() == .75);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
index c73f93a32..22fe4b4ec 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         param_type p = p0;
         assert(p.n() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
index 34476f939..b3bbd8668 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -31,4 +31,6 @@ int main()
         param_type p(10);
         assert(p.n() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
index e40f5d19f..f615acad8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
index 4ecb983b2..a6727c429 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
index eecfbf2fe..d497407e1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
index d211af8bb..e33551deb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
index c7eb0f983..c73d46ccb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
index 6ef45d0d5..9a9670154 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
index 8b5acf399..b29664ee4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.m() == 14.5);
         assert(d.n() == 5.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
index 2762c8dbb..3318d5222 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.m() == 0.25);
         assert(d.n() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
index ea040c9c6..b91da0511 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
index 55c8ccf1b..9a4cdf175 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
@@ -45,7 +45,7 @@ f(double x, double m, double n)
     return I(m * x / (m*x + n), static_cast<unsigned>(m/2), static_cast<unsigned>(n/2));
 }
 
-int main()
+int main(int, char**)
 {
     // Purposefully only testing even integral values of m and n (for now)
     {
@@ -99,4 +99,6 @@ int main()
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], d.m(), d.n()) - double(i)/N) < .01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
index 13818e026..59a19d57e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
@@ -45,7 +45,7 @@ f(double x, double m, double n)
     return I(m * x / (m*x + n), static_cast<unsigned>(m/2), static_cast<unsigned>(n/2));
 }
 
-int main()
+int main(int, char**)
 {
     // Purposefully only testing even integral values of m and n (for now)
     {
@@ -105,4 +105,6 @@ int main()
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], p.m(), p.n()) - double(i)/N) < .01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
index 386696ace..716d852dd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
index c08d61e1d..870d086cc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
index 27bd09fc1..5e9c2968b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
index a3e382c7f..8aca42d94 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
index d026525e7..3622aeb39 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.m() == .75);
         assert(p.n() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
index 21364a393..cc936174c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.m() == 10);
         assert(p.n() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
index 7adacd37b..b7bef507d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.m() == 10);
         assert(p.n() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
index f4fb9bb9f..1345723ec 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
index 3a716bf7c..8fdb9fccf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
index 9164f750f..cad5deda3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
index ee96f3460..567ed9f12 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
index 20157a2ed..567ae63b8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
index 4e73c9d22..f27ea836a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
index d1116cca6..e19839f2a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.m() == 14.5);
         assert(d.s() == 5.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
index f88d43305..09ee798b8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.m() == 0.25);
         assert(d.s() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
index 627f57961..7257f57b1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
index bcbc04c32..908417548 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
@@ -248,11 +248,13 @@ test5()
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
     test5();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
index 350a32587..1c40e66b2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
@@ -258,11 +258,13 @@ test5()
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
     test5();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
index a553901fe..e56cae65b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
index 10ee0e820..204a8f5f3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
index 815db8a89..2297a4160 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
index d199cc0b9..84154865b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
index 3597e6d47..9999b8499 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.m() == .75);
         assert(p.s() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
index a0657ce5c..6ad49592f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.m() == 10);
         assert(p.s() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
index cd533afd8..cb1735b79 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.m() == 10);
         assert(p.s() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
index 8e4cd9a6f..a6be4db10 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
index 7f2b726b1..99f13be07 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
index bc67664b0..992475717 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
index ae8b59b66..6bff26088 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
index 77c3cfbe2..492a0ea6a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
index fa130e4c9..f2326bbc3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
index 508137282..2c4462f25 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.mean() == 14.5);
         assert(d.stddev() == 5.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
index bdb5c69f6..66331187c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.mean() == 0.25);
         assert(d.stddev() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
index ff62af280..87b7c4d7d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
index b2cf8534d..5362aef09 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -66,4 +66,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs(kurtosis - x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
index 55f0c8180..343bdd7dc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -68,4 +68,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs(kurtosis - x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
index f17395501..a29337106 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
index 765c45187..601f8d580 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
index 9218cfa83..24adfc05c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
index 1ec456425..0e2c27a18 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
index 08195232e..4a3786923 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.mean() == .75);
         assert(p.stddev() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
index cc16ec7e3..7ae72e6df 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.mean() == 10);
         assert(p.stddev() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
index f58fd3b5a..e947060e5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.mean() == 10);
         assert(p.stddev() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
index 859dba8a4..cf7fa39cf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
index ef88be799..2fef65e8c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
index 7b4e9ca4b..46f1cb2ee 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
index 754e2c28d..f532786c9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
index e2566347e..bb6ced5e8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
index 0f64eb7cc..a6aa61180 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
index 88827fee4..a133ff30c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         D d(14.5);
         assert(d.n() == 14.5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
index ba286242c..be11e9224 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.n() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
index e51365813..2de6ca551 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
index d8b3783e9..bb1630ea4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -135,4 +135,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
index cb47b07a6..3b939010a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -141,4 +141,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
index f1cd34de7..170aed3db 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
index 8fb8381da..60f9a6fb3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
index f64207c40..f2fe36544 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
index 8f6d4f65b..ab98be450 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
         D d(.5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
index 25137f9c1..54e9313ae 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         p = p0;
         assert(p.n() == .75);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
index b207d7dec..a27a735ca 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         param_type p = p0;
         assert(p.n() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
index bcaac8774..897a3e3cf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -31,4 +31,6 @@ int main()
         param_type p(10);
         assert(p.n() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
index eea4cc99b..cd3a04a34 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
index b064d111c..1acecc1d1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
index 2b4516811..85c6a3cb1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
index c9fc1aacc..f89da9f9e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
index 8ce712a54..bfee1f279 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
index df5b00fb8..41119b4fe 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
index 479f221e0..530d7de9a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         D d(3.5);
         assert(d.lambda() == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
index 31926e520..174e91f8f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.lambda() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
index 27841184c..609f226a5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
index db71f9c90..bfe7e8da3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -148,4 +148,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
index 28f6e6d78..00054a76e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -72,4 +72,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
index c33383261..9cb46bf04 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
index d8b4da1f3..e8613480c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
index bf02b03bd..9859883c1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == std::numeric_limits<D::result_type>::infinity());
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
index abca78185..e19572952 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
index 47ca9d508..9958d632b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         p = p0;
         assert(p.lambda() == .7);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
index df00ddd22..676eac646 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         param_type p = p0;
         assert(p.lambda() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
index 9eb9881f5..8483bf9ff 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -31,4 +31,6 @@ int main()
         param_type p(10);
         assert(p.lambda() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
index 085f55639..e36ffe029 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
index 9e43dff4a..1b137acf9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
index bc3618578..7147b313c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
index fe9f84be0..289c2f1a4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
index 8aab78c07..15333b048 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
index 48f8b46b7..a71dd8e31 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
index 2b02acf62..1123da3f2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
index 3e569438a..4160b0337 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.a() == 0.25);
         assert(d.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
index 8d5e08f5c..ab14c2ac5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
index 42ccae9c8..c83e78e01 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
@@ -192,10 +192,12 @@ test4()
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
index ef1ca6aaf..bf3df4455 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
@@ -200,10 +200,12 @@ test4()
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
index fe300d692..27499a49a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
index 9fefd6058..219d0f1e2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
index b16f7f2a5..bfa6f2483 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
index 199c14e5f..bd97a0ba3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
index cd2aac8ca..b92b6fbe9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.a() == .75);
         assert(p.b() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
index 58ad1f2c9..f64a32030 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.a() == 10);
         assert(p.b() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
index 3dd5e788e..906f7160a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.a() == 10);
         assert(p.b() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
index 532452c2e..c4e4a7060 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
index af00f4b7f..30c46459b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
index f7ff8fdf4..88fff04fb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
index 53ad76218..e96c0d4ad 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
index 707c5b4b1..35eb5c277 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
index b080f76a8..962374efe 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
index c359c08db..31ce06d15 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.alpha() == 14.5);
         assert(d.beta() == 5.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
index a475a67f5..c78821f87 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.alpha() == 0.25);
         assert(d.beta() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
index 932c57a06..ee365f8e7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
index b972c3f5e..f9e678d1c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -147,4 +147,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
index 803daa82e..aeb0bbf31 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -153,4 +153,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
index 31bbbfca8..82b1c9bfd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
index 6824616bd..6732ca210 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
index 29df49967..eb9e2b4f2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
index 37eba2f10..3eda5a651 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
index 447050500..28d3997c4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.alpha() == .75);
         assert(p.beta() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
index d7eb86d23..dc2b32dd7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.alpha() == 10);
         assert(p.beta() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
index 3c72bee5a..333b670f1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.alpha() == 10);
         assert(p.beta() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
index d8cbeb23a..2ba854163 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
index f9467d6a1..0fc07ef95 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
index ca1c4b48d..4af868a27 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
index 197a9b224..31a33c0cf 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
index ee487a416..4379d0bfd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
index 2e141ca92..60fa51933 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
index d5f86cb03..e27d13331 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         D d(3.5);
         assert(d.mean() == 3.5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
index c8ee84146..117adb25a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.mean() == 0.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
index cc7a8bd9d..0d7dda0d9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
index 0e3d1c2e4..588eddba2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -147,4 +147,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
index 27b6a9c39..67f726843 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
@@ -28,7 +28,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -153,4 +153,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
index 8d2b76df2..a55a3837c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
index e8ffce1fa..4aec884f6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
index 853d70749..b1cb12508 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == std::numeric_limits<int>::max());
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
index da95d9c4c..e65319c56 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
index 1982ff5de..393153a7c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         p = p0;
         assert(p.mean() == .7);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
index 841c7ddac..a02e7250f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         param_type p = p0;
         assert(p.mean() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
index 8dea424b4..1e395fdfd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -31,4 +31,6 @@ int main()
         param_type p(10);
         assert(p.mean() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
index 307a0d08d..5e9aa27cc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
index c4e1e434a..b81d15cf0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
index 406b84722..d75e6a1da 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
index 16165b0b7..982919268 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, unsigned long long>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
index c6090b523..ff81b8120 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
index 22d51fc34..0cfafa725 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
index ac093c5f5..3f4d55eb9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -36,4 +36,6 @@ int main()
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
index 4faae698b..e876a2df0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.a() == 0.25);
         assert(d.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
index 12a3e2354..1de323aef 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
index 6d086b87d..88e40b29c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -160,4 +160,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
index 6142f847d..3959f4407 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -166,4 +166,6 @@ int main()
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
index fcc21fb29..c2fbf7b98 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
index 7ecc16f57..6b4f4e9dd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
index 30b504a96..3d9fe0b35 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
index 16a89bcd4..f92384041 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
index 3be04f268..add72f685 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.a() == .75);
         assert(p.b() == 6);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
index 800d6302a..f2b7e95a4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.a() == 10);
         assert(p.b() == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
index f88ba3545..6a03330c1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.a() == 10);
         assert(p.b() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
index 621eda13f..e47f57672 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
index cd7d5209f..08c58d03d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
index 05acfd5e6..f3c5a20d2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
index bd9b47479..51b97e081 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
index a6d6822b6..f1d5b3b24 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
@@ -28,7 +28,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
index 0b1b7b919..19f8dc179 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
@@ -26,7 +26,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
index 89fc479f2..f8d769dbd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         assert(p.size() == 1);
         assert(p[0] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
index 700eb91ba..198b845b3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
@@ -23,7 +23,7 @@ double fw(double x)
     return x+1;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -56,4 +56,6 @@ int main()
         assert(p[1] == .21875);
         assert(p[2] == .28125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
index 51e43f4d2..a9c1e2bb4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -77,4 +77,6 @@ int main()
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
index eafbd1b56..66912cf4a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -83,4 +83,6 @@ int main()
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
index 8a18ab83e..a25c9fbd3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -29,4 +29,6 @@ int main()
         assert(p[0] == 0.25);
         assert(p[1] == 0.75);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
index 302e171ca..409cc39eb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -41,4 +41,6 @@ int main()
         D d2;
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
index 170fc16a7..5dd70d144 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
@@ -19,7 +19,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -275,4 +275,6 @@ int main()
             else
                 assert(u[i] == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
index dbfd5da94..6cc4e90b2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
@@ -19,7 +19,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -41,4 +41,6 @@ int main()
         for (int i = 0; i <= 2; ++i)
             assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
index 26ef68c66..59e331282 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
index 4e95cc477..ff9434c8a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -38,4 +38,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
index c6356cf76..d36576391 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         D d(p0, p0+4);
         assert(d.max() == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
index b40c4c513..259eddc5d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         D d(p0, p0+3);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
index 23decd2b8..c50a2536c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         p = p0;
         assert(p == p0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
index a50a5f424..9b7e6b9ed 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         param_type p = p0;
         assert(p == p0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
index b915e2cb5..680ce405c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.size() == 1);
         assert(p[0] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
index 8d00e6283..4dd919dc4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
@@ -23,7 +23,7 @@ double fw(double x)
     return x+1;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -60,4 +60,6 @@ int main()
         assert(p[1] == .21875);
         assert(p[2] == .28125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
index 69ffe3d46..91adbdb07 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -84,4 +84,6 @@ int main()
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
index aa7d6bfb8..b553ffab1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -90,4 +90,6 @@ int main()
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
index aac1d00fe..3ca678693 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -35,4 +35,6 @@ int main()
         param_type p2;
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
index 558f8ad7f..fab191602 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
index 9334f7245..9858a30a7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -27,4 +27,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
index 99a474a4c..d45475ba3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
index 1de6fd363..3b63601ae 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
@@ -29,7 +29,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
index 6d8e36ef3..82b0d8ef3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
index f05cd9941..836b69008 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -31,4 +31,6 @@ int main()
         assert(dn.size() == 1);
         assert(dn[0] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
index 7c8ae7fa8..7e7537ad8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
@@ -23,7 +23,7 @@ double fw(double x)
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -60,4 +60,6 @@ int main()
         assert(dn[0] == 0.1);
         assert(dn[1] == 0.15);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
index f86cbf56c..22c8a1f4e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
@@ -26,7 +26,7 @@ double f(double x)
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -74,4 +74,6 @@ int main()
         assert(dn[0] == 0.203125);
         assert(dn[1] == 0.1484375);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
index 463e78c85..695a7ba5f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -92,4 +92,6 @@ int main()
         assert(dn[1] == .3125);
         assert(dn[2] == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
index e9439d293..1a10bb31b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         assert(dn[1] == .3125);
         assert(dn[2] == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
index 7cd8b1e06..18b5d59bd 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -43,4 +43,6 @@ int main()
         D d2;
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
index 048fb2d22..d00be22e5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
@@ -723,7 +723,7 @@ test11()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -736,4 +736,6 @@ int main()
     test9();
     test10();
     test11();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
index 0d0e6e50d..c82a6b851 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
@@ -31,7 +31,7 @@ sqr(T x)
     return x*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -95,4 +95,6 @@ int main()
             }
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
index b842d2433..90f469480 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         D d(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
index e4748c15e..b22fdfa58 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
index 7de0052df..19c11c66f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         D d(b, b+Np+1, p);
         assert(d.max() == 17);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
index 601eeecc4..8a5fe519f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         D d(b, b+Np+1, p);
         assert(d.min() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
index 87d78547a..7c42c738c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
index b9a22a153..f9eec8d73 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -29,4 +29,6 @@ int main()
         P p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
index 4b3dad0af..ac2f724b0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         assert(dn.size() == 1);
         assert(dn[0] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
index a8adb5be1..d14a50817 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
@@ -23,7 +23,7 @@ double fw(double x)
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -63,4 +63,6 @@ int main()
         assert(dn[0] == 0.1);
         assert(dn[1] == 0.15);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
index 20a2cdbdc..b7e5a4963 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
@@ -23,7 +23,7 @@ double f(double x)
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -75,4 +75,6 @@ int main()
         assert(dn[0] == 0.203125);
         assert(dn[1] == 0.1484375);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
index 2b11672e2..96dda54d2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -96,4 +96,6 @@ int main()
         assert(dn[1] == .3125);
         assert(dn[2] == .125);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
index c3fe7c42b..4571613f9 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         P p2(b, b+4, p);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
index 99132cdd8..3d4c25e88 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
index b87bd85bc..a34187cb2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         d.param(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
index bfc3cb774..eec866112 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
index d150c8668..ff478a05b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
@@ -29,7 +29,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
index bb87e3113..ba5e6d59a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
index f96a044a4..ded81c974 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -32,4 +32,6 @@ int main()
         assert(dn[0] == 1);
         assert(dn[1] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
index fd42c2256..175774dc0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
@@ -25,7 +25,7 @@ double fw(double x)
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -65,4 +65,6 @@ int main()
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
index e4db52bc9..ab29fecf6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
@@ -26,7 +26,7 @@ double f(double x)
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -78,4 +78,6 @@ int main()
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
index 13517e1cc..541976ad1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -97,4 +97,6 @@ int main()
         assert(dn[2] == 1/4.5);
         assert(dn[3] == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
index 2592763cf..1ecbe87c2 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -38,4 +38,6 @@ int main()
         assert(dn[2] == 12.5/256.25);
         assert(dn[3] == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
index 019335ee7..19eda7357 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -43,4 +43,6 @@ int main()
         D d2;
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
index 1aab615ad..6476f3567 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
@@ -354,7 +354,7 @@ test6()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -362,4 +362,6 @@ int main()
     test4();
     test5();
     test6();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
index 11f2c4926..621320ca4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
@@ -37,7 +37,7 @@ f(double x, double a, double m, double b, double c)
     return a + m*(sqr(x) - sqr(b))/2 + c*(x-b);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -90,4 +90,6 @@ int main()
             assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
index 56e648f50..7776330c0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         D d(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
index 845b64a9f..258fdb77b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -40,4 +40,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
index aa46f40b0..ea6530eae 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         D d(b, b+Np, p);
         assert(d.max() == 17);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
index 28a1b68f2..80c77d6e3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         D d(b, b+Np, p);
         assert(d.min() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
index 3534a8935..145e61630 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -30,4 +30,6 @@ int main()
         p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
index 8d784c669..b409f58f0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -29,4 +29,6 @@ int main()
         P p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
index 5d543cf59..69d4d71f4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -31,4 +31,6 @@ int main()
         assert(dn[0] == 1);
         assert(dn[1] == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
index 48e34c743..c6ea33b1f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
@@ -23,7 +23,7 @@ double fw(double x)
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -66,4 +66,6 @@ int main()
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
index cff26c592..3972715d0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
@@ -23,7 +23,7 @@ double f(double x)
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -79,4 +79,6 @@ int main()
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
index 61122d6f6..4a51902a0 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -101,4 +101,6 @@ int main()
         assert(dn[2] == 1/4.5);
         assert(dn[3] == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
index aab37f7ba..e7a15d683 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         P p2(b, b+4, p);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
index 0907745d8..f6d65ddcc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
index ff96a8657..c5697d7ce 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         d.param(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
index d53117395..9d8bdf6fc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -28,4 +28,6 @@ int main()
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
index 9c4d970b2..e34abf088 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
index 8ddf2f0b3..796aebacc 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
index edbc060d0..8a4fd3358 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         assert(d.a() == -6);
         assert(d.b() == 106);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
index c462f279c..2546810ec 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.a() == 3);
         assert(d.b() == 8);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
index d1614923e..47e1c8953 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(3, 9);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
index 9056a983b..a4e769bd7 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -452,4 +452,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
index 3d4524ca1..77257a865 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
@@ -27,7 +27,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -72,4 +72,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
index 199d9a5b2..62d144fe5 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
index 2205a3f47..3e0296965 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
index cd196ee15..58ac8571f 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
         D d(3, 8);
         assert(d.max() == 8);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
index d1b79a7ff..18b9b5045 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
         D d(3, 8);
         assert(d.min() == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
index eeb8e635c..33d677a91 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
index 33f49ede4..1eae36b96 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
index da9c08ae8..6fbf499ca 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
index 7f76fcc0a..b58a96567 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(6, 10);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
index 84af7f98d..b4844a64b 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
index a67791f3f..59b7b0728 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
index 5cd31e5f6..60ff1cb33 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
index ebdfd0292..e348c04ed 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
@@ -27,7 +27,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
index d53952ccf..4fcc9efc3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
@@ -25,7 +25,9 @@ test1()
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
index 8cb0a1f43..c252c5bbb 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         assert(d.a() == -6);
         assert(d.b() == 106);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
index b2913b772..20df543ea 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         assert(d.a() == 3.5);
         assert(d.b() == 8);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
index ef0eecafd..fb318626d 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -33,4 +33,6 @@ int main()
         D d2(3, 8.1);
         assert(d1 != d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
index aaffa8035..99fe1f825 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
@@ -29,7 +29,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -471,4 +471,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
index 79763903b..495f0e9c3 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
@@ -27,7 +27,7 @@ sqr(T x)
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -71,4 +71,6 @@ int main()
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
index 58918c24f..b60375545 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -25,4 +25,6 @@ int main()
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
index afea0a720..1f6eb5806 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -37,4 +37,6 @@ int main()
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
index ecda47ac3..ea75181f8 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
         D d(3, 8);
         assert(d.max() == 8);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
index 77545c8f2..46455e8b4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
         D d(3, 8);
         assert(d.min() == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
index 1575b7feb..ab4d59693 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -28,4 +28,6 @@ int main()
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
index 9510b2bd5..24260405c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -27,4 +27,6 @@ int main()
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
index 67dc714e4..15cad423e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -40,4 +40,6 @@ int main()
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
index e9ee00564..2127aebf4 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -33,4 +33,6 @@ int main()
         param_type p2(6, 10);
         assert(p1 != p2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
index 5c5ad2331..d2677580e 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -24,4 +24,6 @@ int main()
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
index 021404ba4..f651d72d1 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -26,4 +26,6 @@ int main()
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
index 5b75a0657..431b7374a 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
index 313f4278d..cfaad1a33 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
@@ -48,10 +48,12 @@ test()
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
index c49d36178..355854234 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
@@ -48,10 +48,12 @@ test()
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
index 97d2ef2d2..4f2da2f61 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
@@ -129,7 +129,7 @@ test4()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1<unsigned short>();
     test1<unsigned int>();
@@ -150,4 +150,6 @@ int main()
     test4<unsigned int>();
     test4<unsigned long>();
     test4<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
index a489bcd18..7e82f6395 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned a[] = {3, 5, 7};
@@ -25,4 +25,6 @@ int main()
         std::linear_congruential_engine<unsigned, 5, 7, 11> e2(4);
         assert(e1 == e2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
index 67846b06d..372d98a65 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
@@ -46,10 +46,12 @@ test()
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
index 4848a3d76..dcbb3e065 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
@@ -56,7 +56,7 @@ other()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     rand0<unsigned int>();
     rand0<unsigned long>();
@@ -69,4 +69,6 @@ int main()
     other<unsigned int>();
     other<unsigned long>();
     other<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
index ec217f306..3ee4d9113 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
@@ -70,7 +70,7 @@ Haldir()
     assert(e() == 217250280);
 }
 
-int main()
+int main(int, char**)
 {
     randu<unsigned int>();
     randu<unsigned long>();
@@ -83,4 +83,6 @@ int main()
     Haldir<unsigned int>();
     Haldir<unsigned long>();
     Haldir<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
index 04159baa5..b12de7b01 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
@@ -27,7 +27,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::linear_congruential_engine<unsigned, 48271, 0, 2147483647> E;
@@ -40,4 +40,6 @@ int main()
         is >> e2;
         assert(e1 == e2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
index 569e76050..e0bb2e02c 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
@@ -27,10 +27,12 @@ test()
         T>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
index da944061b..3103bf7ef 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
@@ -30,10 +30,12 @@ test1()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1<unsigned short>();
     test1<unsigned int>();
     test1<unsigned long>();
     test1<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
index c3aec15f6..e7725bd0b 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned a[] = {3, 5, 7};
@@ -35,4 +35,6 @@ int main()
         E e2(sseq);
         assert(e1 == e2);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
index b649b24bb..a8c86bad3 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
@@ -85,10 +85,12 @@ test()
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
index 3ac6d3032..3e1002b06 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
@@ -50,8 +50,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
index eb0486aa7..b1273f1bb 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
@@ -48,8 +48,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
index ae89e6e79..4eca3baad 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
@@ -237,8 +237,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
index d695441cd..b46029a29 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
@@ -301,8 +301,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
index 9f298ea49..a2489cf63 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
@@ -71,10 +71,12 @@ void test(void) {
   assert(e() == X0);
 }
 
-int main() {
+int main(int, char**) {
   // Test for k == 1: word_size <= 32.
   test<unsigned short, 3u>();
 
   // Test for k == 2: (32 < word_size <= 64).
   test<unsigned long long, 33u>();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
index 2d91db790..35364f312 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
@@ -37,8 +37,10 @@ test2()
     assert(e1() == 14514284786278117030ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
index 58d59975d..750afb1e8 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
@@ -47,8 +47,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
index 9d44192f3..03e87dad8 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
@@ -37,8 +37,10 @@ test2()
     assert(e() == 13109570281517897720ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
index 8f7c699ee..cbc764e8d 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
@@ -61,8 +61,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
index ce0506043..7987d6574 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
@@ -36,8 +36,10 @@ test2()
         std::uint_fast64_t>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
index ef529ffcf..ff7d07374 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
@@ -44,8 +44,10 @@ test2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
index 3d05ce779..8ad2ec289 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
@@ -42,8 +42,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
index 62ac9f516..1af1d85b2 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
@@ -126,8 +126,10 @@ test2()
     where(E::default_seed);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
index c05831165..e6cce1b2d 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
@@ -48,8 +48,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
index 70a2b5b2c..c39f39858 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
@@ -46,8 +46,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
index 3045b06c9..5a178e82e 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
@@ -43,8 +43,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
index 361a0fc25..0ed496e71 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
@@ -47,8 +47,10 @@ test2()
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
index 13dede1aa..dbc4c5b4c 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
@@ -34,8 +34,10 @@ test2()
     assert(e1() == 23459059301164ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
index f4824cd9a..4d039289b 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
@@ -44,8 +44,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
index 818d66c44..d8d03c09e 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
@@ -34,8 +34,10 @@ test2()
     assert(e() == 276846226770426ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
index 88d0910d2..d3eeda3be 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
@@ -55,8 +55,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
index cc0fa903a..5312bb1ff 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
@@ -34,8 +34,10 @@ test2()
         std::uint_fast64_t>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
index 201ec38d1..637841a67 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
@@ -42,8 +42,10 @@ test2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
index 2a178388c..85199c0ef 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
@@ -40,8 +40,10 @@ test2()
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
index 758a5957f..a877eff13 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
@@ -74,8 +74,10 @@ test2()
     where(E::default_seed);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp b/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
index a5b9334c6..b06cd4656 100644
--- a/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
@@ -15,9 +15,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::default_random_engine e;
     e.discard(9999);
     LIBCPP_ASSERT(e() == 399268537u);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp b/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
index a06bbe966..d81f788e5 100644
--- a/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::knuth_b e;
     e.discard(9999);
     assert(e() == 1112339016u);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp b/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
index 9a44b4c0a..d38b009e5 100644
--- a/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
@@ -14,9 +14,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::minstd_rand e;
     e.discard(9999);
     assert(e() == 399268537u);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp b/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
index f676f5f00..4e4f07eae 100644
--- a/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
@@ -14,9 +14,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::minstd_rand0 e;
     e.discard(9999);
     assert(e() == 1043618065u);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/mt19937.pass.cpp b/test/std/numerics/rand/rand.predef/mt19937.pass.cpp
index 281666163..16390964f 100644
--- a/test/std/numerics/rand/rand.predef/mt19937.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/mt19937.pass.cpp
@@ -18,9 +18,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::mt19937 e;
     e.discard(9999);
     assert(e() == 4123659995u);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp b/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
index 80ffb429e..c6a3b4ebd 100644
--- a/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
@@ -18,9 +18,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::mt19937_64 e;
     e.discard(9999);
     assert(e() == 9981545732273789042ull);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
index c58f09dcc..9805d1add 100644
--- a/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux24 e;
     e.discard(9999);
     assert(e() == 9901578u);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
index 30d94e696..21c68699b 100644
--- a/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux24_base e;
     e.discard(9999);
     assert(e() == 7937952u);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
index 22c45db40..2ab37e1c7 100644
--- a/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux48 e;
     e.discard(9999);
     assert(e() == 249142670248501ull);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp b/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
index 8faefbb4c..93bb14c5c 100644
--- a/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
+++ b/test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux48_base e;
     e.discard(9999);
     assert(e() == 61839128582725ull);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp b/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
+++ b/test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
index 62e129b98..a05c0846a 100644
--- a/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "truncate_fp.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::minstd_rand0 E;
@@ -98,4 +98,6 @@ int main()
             (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
             ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
index f9a5bc05e..de06a5e9b 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <random>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s0;
     std::seed_seq s;
     s = s0;
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
index 5e6ed7a01..7c3c38ea7 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <random>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s0;
     std::seed_seq s(s0);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
index 1002ea8a4..87608e63c 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
@@ -15,8 +15,10 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s;
     assert(s.size() == 0);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
index db32abddc..e32877778 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         // These numbers generated from a slightly altered version of dSFMT
@@ -801,4 +801,6 @@ int main()
         for (int i = 0; i < n; ++i)
             assert(a[i] == b[i]);
     }
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
index 2d1656a3c..656981b1a 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s= {5, 4, 3, 2, 1};
     assert(s.size() == 5);
@@ -29,4 +29,6 @@ int main()
     assert(b[2] == 3);
     assert(b[3] == 2);
     assert(b[4] == 1);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
index 3b1a79ec3..10f7b3472 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     unsigned a[5] = {5, 4, 3, 2, 1};
     std::seed_seq s(a, a+5);
@@ -28,4 +28,6 @@ int main()
     assert(b[2] == 3);
     assert(b[3] == 2);
     assert(b[4] == 1);
+
+  return 0;
 }
diff --git a/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp b/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
index d169811db..50cfa7d59 100644
--- a/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
+++ b/test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::seed_seq::result_type, std::uint_least32_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/nothing_to_do.pass.cpp b/test/std/re/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/re/nothing_to_do.pass.cpp
+++ b/test/std/re/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/nothing_to_do.pass.cpp b/test/std/re/re.alg/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/re/re.alg/nothing_to_do.pass.cpp
+++ b/test/std/re/re.alg/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/awk.pass.cpp b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
index 095980c60..43fc9b89c 100644
--- a/test/std/re/re.alg/re.alg.match/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/awk.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1391,4 +1391,5 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+    return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/basic.fail.cpp b/test/std/re/re.alg/re.alg.match/basic.fail.cpp
index bc5e4b75d..d71fc280a 100644
--- a/test/std/re/re.alg/re.alg.match/basic.fail.cpp
+++ b/test/std/re/re.alg/re.alg.match/basic.fail.cpp
@@ -25,11 +25,13 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::smatch m;
         std::regex re{"*"};
         std::regex_match(std::string("abcde"), m, re);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/basic.pass.cpp b/test/std/re/re.alg/re.alg.match/basic.pass.cpp
index d6a0b0da7..b2fa6e941 100644
--- a/test/std/re/re.alg/re.alg.match/basic.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/basic.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1367,4 +1367,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/ecma.pass.cpp b/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
index c1e910c77..e15533da6 100644
--- a/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1391,4 +1391,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/egrep.pass.cpp b/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
index 8789e7d73..4e1b6940c 100644
--- a/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/egrep.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -78,4 +78,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == "tourna");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
index f23bef36e..a1ba80f26 100644
--- a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
diff --git a/test/std/re/re.alg/re.alg.match/extended.pass.cpp b/test/std/re/re.alg/re.alg.match/extended.pass.cpp
index b04d750a3..9415505fa 100644
--- a/test/std/re/re.alg/re.alg.match/extended.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/extended.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1363,4 +1363,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/grep.pass.cpp b/test/std/re/re.alg/re.alg.match/grep.pass.cpp
index 0c68dca69..0f75d618c 100644
--- a/test/std/re/re.alg/re.alg.match/grep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/grep.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -46,4 +46,6 @@ int main()
                 std::regex_constants::grep)));
         assert(m.size() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp b/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
index 67bfd96f4..d48d86ee6 100644
--- a/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
@@ -15,7 +15,7 @@
 #include <regex>
 
 
-int main() {
+int main(int, char**) {
     assert(std::regex_match("X", std::regex("[X]")));
     assert(std::regex_match("X", std::regex("[XY]")));
     assert(!std::regex_match("X", std::regex("[^X]")));
@@ -40,4 +40,6 @@ int main() {
     assert(!std::regex_match("_", std::regex("[\\W]")));
     assert(std::regex_match("X", std::regex("[^\\W]")));
     assert(std::regex_match("_", std::regex("[^\\W]")));
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp b/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
index ec8467f4e..1550f3728 100644
--- a/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex re("^(?=(.))a$");
@@ -95,4 +95,6 @@ int main()
         assert(m[3] == "a");
         assert(m[4] == "");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
index b6d3e1ae3..291798cfc 100644
--- a/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
+++ b/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
@@ -62,10 +62,12 @@ test4()
     assert((std::regex_match(target, smatch, regex)));
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp b/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
index 715aa0aff..868c3d835 100644
--- a/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     try {
         std::regex re("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa");
@@ -35,4 +35,5 @@ int main()
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
+    return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.replace/test1.pass.cpp b/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
index df68aae93..7e5332aaf 100644
--- a/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -104,4 +104,6 @@ int main()
         assert(r.base() == buf+12);
         assert(buf == std::string("123-555-1234"));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.replace/test2.pass.cpp b/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
index 1cfaec679..d5e3b64a3 100644
--- a/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -104,4 +104,6 @@ int main()
         assert(r.base() == buf+12);
         assert(buf == std::string("123-555-1234"));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.replace/test3.pass.cpp b/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
index ebfb20d7b..09ecc53a9 100644
--- a/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test3.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -70,4 +70,6 @@ int main()
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.replace/test4.pass.cpp b/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
index 88816e3d7..4d567ed1f 100644
--- a/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test4.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -69,4 +69,6 @@ int main()
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.replace/test5.pass.cpp b/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
index bcff51edd..585a60f87 100644
--- a/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test5.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -70,4 +70,6 @@ int main()
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.replace/test6.pass.cpp b/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
index 923230aea..66a910172 100644
--- a/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
+++ b/test/std/re/re.alg/re.alg.replace/test6.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -70,4 +70,6 @@ int main()
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/awk.pass.cpp b/test/std/re/re.alg/re.alg.search/awk.pass.cpp
index 13f9646f4..0f8fb14f5 100644
--- a/test/std/re/re.alg/re.alg.search/awk.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/awk.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1574,4 +1574,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/backup.pass.cpp b/test/std/re/re.alg/re.alg.search/backup.pass.cpp
index 710cf226c..d27124a8d 100644
--- a/test/std/re/re.alg/re.alg.search/backup.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/backup.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     // This regex_iterator uses regex_search(__wrap_iter<_Iter> __first, ...)
     // Test for https://bugs.llvm.org/show_bug.cgi?id=16240 fixed in r185273.
@@ -60,4 +60,6 @@ int main()
         ++it;
         assert(it == end);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/basic.fail.cpp b/test/std/re/re.alg/re.alg.search/basic.fail.cpp
index d84b1c97b..fb9677f7e 100644
--- a/test/std/re/re.alg/re.alg.search/basic.fail.cpp
+++ b/test/std/re/re.alg/re.alg.search/basic.fail.cpp
@@ -25,11 +25,13 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::smatch m;
         std::regex re{"*"};
         std::regex_search(std::string("abcde"), m, re);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/basic.pass.cpp b/test/std/re/re.alg/re.alg.search/basic.pass.cpp
index ee919b223..bd96c9830 100644
--- a/test/std/re/re.alg/re.alg.search/basic.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/basic.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1547,4 +1547,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/ecma.pass.cpp b/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
index afc5a005b..7e74caa08 100644
--- a/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1589,4 +1589,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/egrep.pass.cpp b/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
index 4e3295260..df8560f5f 100644
--- a/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/egrep.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -87,4 +87,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == "tourna");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
index 6de3bbffd..a9eb2b2b9 100644
--- a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
diff --git a/test/std/re/re.alg/re.alg.search/extended.pass.cpp b/test/std/re/re.alg/re.alg.search/extended.pass.cpp
index 6c9cabeff..62e4822db 100644
--- a/test/std/re/re.alg/re.alg.search/extended.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/extended.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1543,4 +1543,6 @@ int main()
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/grep.pass.cpp b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
index 8844b4e6f..29300a818 100644
--- a/test/std/re/re.alg/re.alg.search/grep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
@@ -50,7 +50,7 @@ void fuzz_tests()  // patterns that the fuzzer has found
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -85,4 +85,6 @@ int main()
         assert(m.str(0) == "");
     }
     fuzz_tests();
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
index 98343f554..63fd5ae57 100644
--- a/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
@@ -20,7 +20,7 @@
 
 
 // PR34310
-int main()
+int main(int, char**)
 {
   assert(std::regex_search("HelloWorld", std::regex("[^\\W]")));
   assert(std::regex_search("_", std::regex("[^\\W]")));
diff --git a/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp b/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
index b4a47f09b..7846eca2a 100644
--- a/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
@@ -21,8 +21,10 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(!std::regex_search("ab", std::regex("(?=^)b")));
     assert(!std::regex_search("ab", std::regex("a(?=^)b")));
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp b/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
index 8bfcfa007..73158dc53 100644
--- a/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     // Iterating over /^a/ should yield one instance at the beginning
     // of the text.
@@ -35,4 +35,6 @@ int main()
 
     ++it;
     assert(it == end);
+
+  return 0;
 }
diff --git a/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp b/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
+++ b/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.badexp/regex_error.pass.cpp b/test/std/re/re.badexp/regex_error.pass.cpp
index efcc44f6a..a3f4476b0 100644
--- a/test/std/re/re.badexp/regex_error.pass.cpp
+++ b/test/std/re/re.badexp/regex_error.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_error e(std::regex_constants::error_collate);
@@ -93,4 +93,6 @@ int main()
         assert(e.what() == std::string("There was insufficient memory to determine whether the regular "
                "expression could match the specified character sequence."));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.const/nothing_to_do.pass.cpp b/test/std/re/re.const/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.const/nothing_to_do.pass.cpp
+++ b/test/std/re/re.const/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.const/re.err/error_type.pass.cpp b/test/std/re/re.const/re.err/error_type.pass.cpp
index 4369e0170..51979a511 100644
--- a/test/std/re/re.const/re.err/error_type.pass.cpp
+++ b/test/std/re/re.const/re.err/error_type.pass.cpp
@@ -35,7 +35,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_constants::error_collate != 0);
     assert(std::regex_constants::error_ctype != 0);
@@ -140,4 +140,6 @@ int main()
     assert(std::regex_constants::error_badrepeat != std::regex_constants::error_stack);
 
     assert(std::regex_constants::error_complexity != std::regex_constants::error_stack);
+
+  return 0;
 }
diff --git a/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp b/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
index bed42547b..812601463 100644
--- a/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
@@ -35,7 +35,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_constants::match_default == 0);
     assert(std::regex_constants::match_not_bol != 0);
@@ -125,4 +125,6 @@ int main()
     e1 &= e2;
     e1 |= e2;
     e1 ^= e2;
+
+  return 0;
 }
diff --git a/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
index e32736630..82395e2f2 100644
--- a/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string target = "foo";
@@ -47,4 +47,6 @@ int main()
     assert( std::regex_search(target, re));
     assert( std::regex_search(target, re, std::regex_constants::match_not_bol));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
index 3d238c5d0..8b13c68bc 100644
--- a/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string target = "foo";
@@ -47,4 +47,6 @@ int main()
     assert( std::regex_search(target, re));
     assert( std::regex_search(target, re, std::regex_constants::match_not_eol));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp b/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
index d3389e6b6..645f79a0d 100644
--- a/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
+++ b/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
@@ -15,7 +15,7 @@
 #include <cassert>
 #include <regex>
 
-int main()
+int main(int, char**)
 {
   // When match_not_null is on, the regex engine should reject empty matches and
   // move on to try other solutions.
diff --git a/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp b/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
index 7af7e8cf4..49ce2b5c4 100644
--- a/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
+++ b/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
@@ -32,7 +32,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_constants::icase != 0);
     assert(std::regex_constants::nosubs != 0);
@@ -111,4 +111,6 @@ int main()
     e1 &= e2;
     e1 |= e2;
     e1 ^= e2;
+
+  return 0;
 }
diff --git a/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp b/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.def/nothing_to_do.pass.cpp b/test/std/re/re.def/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.def/nothing_to_do.pass.cpp
+++ b/test/std/re/re.def/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.general/nothing_to_do.pass.cpp b/test/std/re/re.general/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.general/nothing_to_do.pass.cpp
+++ b/test/std/re/re.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.grammar/excessive_brace_count.pass.cpp b/test/std/re/re.grammar/excessive_brace_count.pass.cpp
index 49bd06e5c..a5f28d2ee 100644
--- a/test/std/re/re.grammar/excessive_brace_count.pass.cpp
+++ b/test/std/re/re.grammar/excessive_brace_count.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::basic, std::regex::grep}) {
     try {
diff --git a/test/std/re/re.grammar/nothing_to_do.pass.cpp b/test/std/re/re.grammar/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/re/re.grammar/nothing_to_do.pass.cpp
+++ b/test/std/re/re.grammar/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/nothing_to_do.pass.cpp b/test/std/re/re.iter/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/re/re.iter/nothing_to_do.pass.cpp
+++ b/test/std/re/re.iter/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
index 17cce2cb4..34d1ce6ed 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
@@ -24,7 +24,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
@@ -32,4 +32,6 @@ int main()
             std::begin(phone_book), std::end(phone_book),
             std::regex("\\d{3}-\\d{4}"));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
index d944806fd..a6d105974 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -41,4 +41,6 @@ int main()
         ++i;
         assert(i == std::cregex_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
index ca5670bbb..75bd9cab5 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
@@ -25,8 +25,10 @@ test()
     assert(i1 == I());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
index 55b506be1..f7f71bc8b 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
@@ -13,6 +13,8 @@
 // bool operator==(const regex_iterator& right) const;
 // bool operator!=(const regex_iterator& right) const;
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
index 2643cebc7..11b12b2ee 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -39,4 +39,6 @@ int main()
         ++i;
         assert(i == std::cregex_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
index be4126e3e..ad65f7c13 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -112,4 +112,6 @@ int main()
         ++i;
         assert(i == e);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.regiter/types.pass.cpp b/test/std/re/re.iter/re.regiter/types.pass.cpp
index 07c3fa64b..b96fec78a 100644
--- a/test/std/re/re.iter/re.regiter/types.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/types.pass.cpp
@@ -38,8 +38,10 @@ test()
     static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
index bddf58210..a03fd52c0 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
@@ -26,7 +26,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -35,4 +35,6 @@ int main()
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                      std::regex("\\d{3}-\\d{4}"), indices);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
index eadfbdb44..254909a92 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -61,4 +61,6 @@ int main()
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
index cdbf1a591..bb70095f1 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
@@ -25,8 +25,10 @@ test()
     assert(i1 == I());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
index 87a227af0..b6913e6b3 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
@@ -24,7 +24,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -32,4 +32,6 @@ int main()
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                       std::regex("\\d{3}-\\d{4}"), {-1, 0, 1});
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
index 8ecd0bab4..322c2682d 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
@@ -22,7 +22,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -61,4 +61,6 @@ int main()
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
index 82e067818..3c39d4983 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
@@ -23,7 +23,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -31,4 +31,6 @@ int main()
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                      std::regex("\\d{3}-\\d{4}"), -1);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
index c2213a0af..1e5ba2eca 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -72,4 +72,6 @@ int main()
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
index 9e8fe86ed..9b07df9d1 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
@@ -25,7 +25,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
          std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -36,4 +36,6 @@ int main()
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                      std::regex("\\d{3}-\\d{4}"), v);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
index 5f31c5795..1d77deb91 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -125,4 +125,6 @@ int main()
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
index f4de410b2..1c6020103 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -33,4 +33,6 @@ int main()
         assert(!(i2 == i));
         assert(i2 != i);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
index edde79c16..facd24367 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -69,4 +69,6 @@ int main()
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp b/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
index c4095ebf6..15f1bb7c8 100644
--- a/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -132,4 +132,6 @@ int main()
         i++;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.iter/re.tokiter/types.pass.cpp b/test/std/re/re.iter/re.tokiter/types.pass.cpp
index 58803aa1a..73ad58f4e 100644
--- a/test/std/re/re.iter/re.tokiter/types.pass.cpp
+++ b/test/std/re/re.iter/re.tokiter/types.pass.cpp
@@ -38,8 +38,10 @@ test()
     static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
index daaac65be..532a72073 100644
--- a/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'});
@@ -30,4 +30,6 @@ int main()
     r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/assign.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
index 9507ea310..c580ab96c 100644
--- a/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
@@ -34,4 +34,6 @@ int main()
     assert(r2.mark_count() == 2);
     assert(std::regex_search("ab", r2));
 #endif
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
index 9eba95b33..dd32c9466 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     typedef input_iterator<std::string::const_iterator> I;
     typedef forward_iterator<std::string::const_iterator> F;
@@ -43,4 +43,6 @@ int main()
     r2.assign(F(s4.begin()), F(s4.end()), std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
index 30c7281da..9445bbaf9 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign("(a([bc]))");
@@ -26,4 +26,6 @@ int main()
     r2.assign("(a([bc]))", std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
index 08fdf871d..cdbdae430 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
@@ -16,10 +16,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign("(a([bc]))", 9, std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp b/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
index 7ea385967..4b1bcef9a 100644
--- a/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign(std::string("(a([bc]))"));
@@ -28,4 +28,6 @@ int main()
     r2.assign(std::string("(a([bc]))"), std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/copy.pass.cpp b/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
index c74f0a6f0..1abb72151 100644
--- a/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
@@ -16,11 +16,13 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
     r2 = r1;
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/il.pass.cpp b/test/std/re/re.regex/re.regex.assign/il.pass.cpp
index 75803e600..880fd5c79 100644
--- a/test/std/re/re.regex/re.regex.assign/il.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/il.pass.cpp
@@ -18,10 +18,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2 = {'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'};
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp b/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
index f2ca05a9b..3791f8152 100644
--- a/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
@@ -16,10 +16,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2 = "(a([bc]))";
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.assign/string.pass.cpp b/test/std/re/re.regex/re.regex.assign/string.pass.cpp
index 3cb8e8b41..e33819ab3 100644
--- a/test/std/re/re.regex/re.regex.assign/string.pass.cpp
+++ b/test/std/re/re.regex/re.regex.assign/string.pass.cpp
@@ -17,10 +17,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2 = std::string("(a([bc]))");
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.const/constants.pass.cpp b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
index 3fc28e4ec..5d8d48d05 100644
--- a/test/std/re/re.regex/re.regex.const/constants.pass.cpp
+++ b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
@@ -58,8 +58,10 @@ test()
     where(BR::egrep);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp b/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
index eabf8eab9..2e7eed350 100644
--- a/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::regex_constants::awk;
 
@@ -25,4 +25,6 @@ int main()
     assert(std::regex_match("\41", std::regex("\\41", awk)));
     assert(std::regex_match("\141", std::regex("\\141", awk)));
     assert(std::regex_match("\141" "1", std::regex("\\1411", awk)));
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
index cc1b081c7..0a15b6453 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
@@ -29,7 +29,7 @@ static bool error_badbackref_thrown(const char *pat)
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_badbackref_thrown("\\1abc"));      // no references
     assert(error_badbackref_thrown("ab(c)\\2def")); // only one reference
@@ -41,4 +41,6 @@ int main()
     const char *pat1 = "a(b)c\\1234";
     std::regex re(pat1, pat1 + 7); // extra chars after the end.
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
index dc24531cb..5752d5cd6 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
@@ -29,8 +29,10 @@ static bool error_ctype_thrown(const char *pat)
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_ctype_thrown("[[::]]"));
     assert(error_ctype_thrown("[[:error:]]"));
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
index f9e589ce7..041d55bdf 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
@@ -29,7 +29,7 @@ static bool error_escape_thrown(const char *pat)
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_escape_thrown("[\\a]"));
     assert(error_escape_thrown("\\a"));
@@ -44,4 +44,6 @@ int main()
     assert(!error_escape_thrown("[\\cA]"));
     assert(!error_escape_thrown("\\cA"));
 
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
index 2d07e1e8c..1af8b5ba6 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
@@ -29,7 +29,7 @@ static bool error_badrepeat_thrown(const char *pat)
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_badrepeat_thrown("?a"));
     assert(error_badrepeat_thrown("*a"));
@@ -40,4 +40,6 @@ int main()
     assert(error_badrepeat_thrown("*(a+)"));
     assert(error_badrepeat_thrown("+(a+)"));
     assert(error_badrepeat_thrown("{(a+)"));
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/copy.pass.cpp b/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
index 588f673bf..f3db8fe06 100644
--- a/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
@@ -16,10 +16,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2 = r1;
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp b/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
index 5ece59ad2..30ec49c83 100644
--- a/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
+++ b/test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
@@ -24,7 +24,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -41,4 +41,6 @@ int main()
 
 //  Test the implicit deduction guides
 
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp b/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
index 5d7493ae6..47e5a1dba 100644
--- a/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
@@ -31,7 +31,7 @@ using namespace std::literals;
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -133,4 +133,6 @@ int main()
     assert(re.flags() == std::regex_constants::grep);
     assert(re.mark_count() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/default.pass.cpp b/test/std/re/re.regex/re.regex.construct/default.pass.cpp
index b5c1521fc..f706229e6 100644
--- a/test/std/re/re.regex/re.regex.construct/default.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/default.pass.cpp
@@ -25,8 +25,10 @@ test()
     assert(r.mark_count() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
index aac13147e..aaf5bc25a 100644
--- a/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
@@ -29,7 +29,7 @@ test(std::initializer_list<char> il, std::regex_constants::syntax_option_type f,
 }
 
 
-int main()
+int main(int, char**)
 {
     std::string s1("\\(a\\)");
     std::string s2("\\(a[bc]\\)");
@@ -65,4 +65,6 @@ int main()
     test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::egrep, 0);
     test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::egrep, 0);
     test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::egrep, 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp b/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
index 0b5d0c504..3dcf29fa0 100644
--- a/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
@@ -28,7 +28,7 @@ test(Iter first, Iter last, unsigned mc)
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     typedef forward_iterator<std::string::const_iterator> F;
     std::string s1("\\(a\\)");
@@ -40,4 +40,6 @@ int main()
     test(F(s2.begin()), F(s2.end()), 0);
     test(F(s3.begin()), F(s3.end()), 0);
     test(F(s4.begin()), F(s4.end()), 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
index 37878347f..22423c092 100644
--- a/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
@@ -29,7 +29,7 @@ test(Iter first, Iter last, std::regex_constants::syntax_option_type f, unsigned
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     typedef forward_iterator<std::string::const_iterator> F;
     std::string s1("\\(a\\)");
@@ -66,4 +66,6 @@ int main()
     test(F(s2.begin()), F(s2.end()), std::regex_constants::egrep, 0);
     test(F(s3.begin()), F(s3.end()), std::regex_constants::egrep, 0);
     test(F(s4.begin()), F(s4.end()), std::regex_constants::egrep, 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
index 877b9a4c6..b71d9eb7f 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
@@ -25,10 +25,12 @@ test(const CharT* p, unsigned mc)
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", 0);
     test("\\(a[bc]\\)", 0);
     test("\\(a\\([bc]\\)\\)", 0);
     test("(a([bc]))", 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
index 998f28db8..e918b0311 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
@@ -25,7 +25,7 @@ test(const CharT* p, std::regex_constants::syntax_option_type f, unsigned mc)
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", std::regex_constants::basic, 1);
     test("\\(a[bc]\\)", std::regex_constants::basic, 1);
@@ -56,4 +56,6 @@ int main()
     test("\\(a[bc]\\)", std::regex_constants::egrep, 0);
     test("\\(a\\([bc]\\)\\)", std::regex_constants::egrep, 0);
     test("(a([bc]))", std::regex_constants::egrep, 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
index 03a53b769..29fa3ca57 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
@@ -24,7 +24,7 @@ test(const CharT* p, std::size_t len, unsigned mc)
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", 5, 0);
     test("\\(a[bc]\\)", 9, 0);
@@ -35,4 +35,6 @@ int main()
     test("(\0)(b)(c)(d)", 9, 3);
     test("(\0)(b)(c)(d)", 3, 1);
     test("(\0)(b)(c)(d)", 0, 0);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
index 8546c1673..07f394731 100644
--- a/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
@@ -26,7 +26,7 @@ test(const CharT* p, std::size_t len, std::regex_constants::syntax_option_type f
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", 5, std::regex_constants::basic, 1);
     test("\\(a[bc]\\)", 9, std::regex_constants::basic, 1);
@@ -57,4 +57,6 @@ int main()
     test("\\(a[bc]\\)", 9, std::regex_constants::egrep, 0);
     test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::egrep, 0);
     test("(a([bc]))", 9, std::regex_constants::egrep, 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/string.pass.cpp b/test/std/re/re.regex/re.regex.construct/string.pass.cpp
index 58f607183..ecd0451d8 100644
--- a/test/std/re/re.regex/re.regex.construct/string.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/string.pass.cpp
@@ -26,10 +26,12 @@ test(const String& p, unsigned mc)
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("\\(a\\)"), 0);
     test(std::string("\\(a[bc]\\)"), 0);
     test(std::string("\\(a\\([bc]\\)\\)"), 0);
     test(std::string("(a([bc]))"), 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp b/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
index 6d504db33..b6bd8c53c 100644
--- a/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
@@ -27,7 +27,7 @@ test(const String& p, std::regex_constants::syntax_option_type f, unsigned mc)
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("\\(a\\)"), std::regex_constants::basic, 1);
     test(std::string("\\(a[bc]\\)"), std::regex_constants::basic, 1);
@@ -58,4 +58,6 @@ int main()
     test(std::string("\\(a[bc]\\)"), std::regex_constants::egrep, 0);
     test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::egrep, 0);
     test(std::string("(a([bc]))"), std::regex_constants::egrep, 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp b/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
index a985a74e9..27647f123 100644
--- a/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
+++ b/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::regex r;
     std::locale loc = r.imbue(std::locale(LOCALE_en_US_UTF_8));
@@ -30,4 +30,6 @@ int main()
     loc = r.imbue(std::locale("C"));
     assert(loc.name() == LOCALE_en_US_UTF_8);
     assert(r.getloc().name() == "C");
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp b/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
+++ b/test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp b/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
index dc5ad95cb..bb3291be6 100644
--- a/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
+++ b/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
@@ -26,4 +26,6 @@ int main()
     assert(r1.mark_count() == 0);
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp b/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
+++ b/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/re.regex.swap/swap.pass.cpp b/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
index b519edc25..5092d57c1 100644
--- a/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
+++ b/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
@@ -25,4 +25,6 @@ int main()
     assert(r1.mark_count() == 0);
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.regex/types.pass.cpp b/test/std/re/re.regex/types.pass.cpp
index 21a563890..a13ad180d 100644
--- a/test/std/re/re.regex/types.pass.cpp
+++ b/test/std/re/re.regex/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::basic_regex<char>::value_type, char>::value), "");
     static_assert((std::is_same<std::basic_regex<char>::traits_type, std::regex_traits<char> >::value), "");
@@ -38,4 +38,6 @@ int main()
     static_assert((std::is_same<std::basic_regex<wchar_t>::flag_type,
                                 std::regex_constants::syntax_option_type>::value), "");
     static_assert((std::is_same<std::basic_regex<wchar_t>::locale_type, std::locale>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.req/nothing_to_do.pass.cpp b/test/std/re/re.req/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/re/re.req/nothing_to_do.pass.cpp
+++ b/test/std/re/re.req/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/begin_end.pass.cpp b/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
index d83ef300f..48fff58b0 100644
--- a/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
@@ -33,7 +33,9 @@ test()
         assert(*i == m[j]);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp b/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
index 9b8db2587..bd9009a8a 100644
--- a/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
@@ -33,7 +33,9 @@ test()
         assert(*i == m[j]);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/index.pass.cpp b/test/std/re/re.results/re.results.acc/index.pass.cpp
index e3f6215e9..a5c25a82c 100644
--- a/test/std/re/re.results/re.results.acc/index.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/index.pass.cpp
@@ -46,8 +46,10 @@ test(std::regex_constants::syntax_option_type syntax)
     assert(m[4].matched == false);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::regex_constants::ECMAScript);
     test(std::regex_constants::extended);
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/length.pass.cpp b/test/std/re/re.results/re.results.acc/length.pass.cpp
index d7d68c5e0..266ba692f 100644
--- a/test/std/re/re.results/re.results.acc/length.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/length.pass.cpp
@@ -30,7 +30,9 @@ test()
     assert(m.length(4) == m[4].length());
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/position.pass.cpp b/test/std/re/re.results/re.results.acc/position.pass.cpp
index 18aa79a48..34256de35 100644
--- a/test/std/re/re.results/re.results.acc/position.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/position.pass.cpp
@@ -30,7 +30,9 @@ test()
     assert(m.position(4) == std::distance(s, m[4].first));
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/prefix.pass.cpp b/test/std/re/re.results/re.results.acc/prefix.pass.cpp
index ab389cc45..b2cd48d4d 100644
--- a/test/std/re/re.results/re.results.acc/prefix.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/prefix.pass.cpp
@@ -28,7 +28,9 @@ test()
     assert(m.prefix().matched == true);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/str.pass.cpp b/test/std/re/re.results/re.results.acc/str.pass.cpp
index ae5f5c7f6..ae4387d46 100644
--- a/test/std/re/re.results/re.results.acc/str.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/str.pass.cpp
@@ -30,7 +30,9 @@ test()
     assert(m.str(4) == std::string(m[4]));
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.acc/suffix.pass.cpp b/test/std/re/re.results/re.results.acc/suffix.pass.cpp
index 7e88ab106..c9d3855e9 100644
--- a/test/std/re/re.results/re.results.acc/suffix.pass.cpp
+++ b/test/std/re/re.results/re.results.acc/suffix.pass.cpp
@@ -28,7 +28,9 @@ test()
     assert(m.suffix().matched == true);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.all/get_allocator.pass.cpp b/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
index 1e0a3ce27..f0dcd7b6d 100644
--- a/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
+++ b/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
@@ -28,8 +28,10 @@ test(const Allocator& a)
     assert(m.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>(test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.const/allocator.pass.cpp b/test/std/re/re.results/re.results.const/allocator.pass.cpp
index f8a5a83fe..99ecb667b 100644
--- a/test/std/re/re.results/re.results.const/allocator.pass.cpp
+++ b/test/std/re/re.results/re.results.const/allocator.pass.cpp
@@ -28,8 +28,10 @@ test(const Allocator& a)
     assert(m.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>(test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.const/copy.pass.cpp b/test/std/re/re.results/re.results.const/copy.pass.cpp
index f6733bdd1..a1dbea0e8 100644
--- a/test/std/re/re.results/re.results.const/copy.pass.cpp
+++ b/test/std/re/re.results/re.results.const/copy.pass.cpp
@@ -30,11 +30,13 @@ test(const Allocator& a)
     assert(m1.get_allocator() == m0.get_allocator());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
 
     test<char>   (test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.const/copy_assign.pass.cpp b/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
index 3429b066b..943037e75 100644
--- a/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
+++ b/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
@@ -34,7 +34,7 @@ test(const Allocator& a)
         assert(m1.get_allocator() == Allocator());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
@@ -46,4 +46,6 @@ int main()
 //  other_allocator has POCCA -> true
     test<char>   (other_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.const/default.pass.cpp b/test/std/re/re.results/re.results.const/default.pass.cpp
index 80f4a0269..a70c3441d 100644
--- a/test/std/re/re.results/re.results.const/default.pass.cpp
+++ b/test/std/re/re.results/re.results.const/default.pass.cpp
@@ -26,8 +26,10 @@ test()
     assert(m.get_allocator() == std::allocator<std::sub_match<const CharT*> >());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.const/move.pass.cpp b/test/std/re/re.results/re.results.const/move.pass.cpp
index b3d2a0f41..778e31b26 100644
--- a/test/std/re/re.results/re.results.const/move.pass.cpp
+++ b/test/std/re/re.results/re.results.const/move.pass.cpp
@@ -35,7 +35,7 @@ test(const Allocator& a)
     assert(m1.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
@@ -44,4 +44,6 @@ int main()
     assert(test_alloc_base::moved == 1);
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
     assert(test_alloc_base::moved == 2);
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.const/move_assign.pass.cpp b/test/std/re/re.results/re.results.const/move_assign.pass.cpp
index 55c66e9e1..2a62af8f2 100644
--- a/test/std/re/re.results/re.results.const/move_assign.pass.cpp
+++ b/test/std/re/re.results/re.results.const/move_assign.pass.cpp
@@ -35,7 +35,7 @@ test(const Allocator& a)
         assert(m1.get_allocator() == Allocator());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
@@ -47,4 +47,6 @@ int main()
 //  other_allocator has POCMA -> true
     test<char>   (other_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.form/form1.pass.cpp b/test/std/re/re.results/re.results.form/form1.pass.cpp
index 6046f9be0..f435de827 100644
--- a/test/std/re/re.results/re.results.form/form1.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form1.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::match_results<const char*> m;
@@ -152,4 +152,6 @@ int main()
         assert(r == out + 34);
         assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.form/form2.pass.cpp b/test/std/re/re.results/re.results.form/form2.pass.cpp
index 2c9d30eb2..b28c064e1 100644
--- a/test/std/re/re.results/re.results.form/form2.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form2.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_iterators.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
     typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
@@ -99,4 +99,6 @@ int main()
         assert(r == out + 34);
         assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.form/form3.pass.cpp b/test/std/re/re.results/re.results.form/form3.pass.cpp
index ca1a30732..62a735ca6 100644
--- a/test/std/re/re.results/re.results.form/form3.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form3.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
     typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
@@ -82,4 +82,6 @@ int main()
         wstr out = m.format(fmt, std::regex_constants::format_sed);
         assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.form/form4.pass.cpp b/test/std/re/re.results/re.results.form/form4.pass.cpp
index d46d6248d..658e788b6 100644
--- a/test/std/re/re.results/re.results.form/form4.pass.cpp
+++ b/test/std/re/re.results/re.results.form/form4.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::match_results<const char*> m;
@@ -77,4 +77,6 @@ int main()
         std::wstring out = m.format(fmt, std::regex_constants::format_sed);
         assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.nonmember/equal.pass.cpp b/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
index e0b53609a..3723ad474 100644
--- a/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
+++ b/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
@@ -40,7 +40,9 @@ test()
     assert(m1 == m2);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.size/empty.fail.cpp b/test/std/re/re.results/re.results.size/empty.fail.cpp
index 7a92dd88e..e17c77424 100644
--- a/test/std/re/re.results/re.results.size/empty.fail.cpp
+++ b/test/std/re/re.results/re.results.size/empty.fail.cpp
@@ -19,8 +19,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::match_results<const char*> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.size/empty.pass.cpp b/test/std/re/re.results/re.results.size/empty.pass.cpp
index 4644a8afb..7eaed34ac 100644
--- a/test/std/re/re.results/re.results.size/empty.pass.cpp
+++ b/test/std/re/re.results/re.results.size/empty.pass.cpp
@@ -30,7 +30,9 @@ test()
     assert(m.size() == 3);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.size/max_size.pass.cpp b/test/std/re/re.results/re.results.size/max_size.pass.cpp
index 5293f45f7..184933d13 100644
--- a/test/std/re/re.results/re.results.size/max_size.pass.cpp
+++ b/test/std/re/re.results/re.results.size/max_size.pass.cpp
@@ -24,8 +24,10 @@ test()
     assert(m.max_size() > 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.state/ready.pass.cpp b/test/std/re/re.results/re.results.state/ready.pass.cpp
index daa1bf337..476a66fdf 100644
--- a/test/std/re/re.results/re.results.state/ready.pass.cpp
+++ b/test/std/re/re.results/re.results.state/ready.pass.cpp
@@ -36,8 +36,10 @@ test2()
     assert(m.ready() == true);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.swap/member_swap.pass.cpp b/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
index 9cb6ae441..967fe11c5 100644
--- a/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
+++ b/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
@@ -33,7 +33,9 @@ test()
     assert(m2 == m1_save);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp b/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
index 21724fc49..59ba59f3d 100644
--- a/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
+++ b/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
@@ -35,7 +35,9 @@ test()
     assert(m2 == m1_save);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
diff --git a/test/std/re/re.results/types.pass.cpp b/test/std/re/re.results/types.pass.cpp
index 3f5a31d0d..0fd822084 100644
--- a/test/std/re/re.results/types.pass.cpp
+++ b/test/std/re/re.results/types.pass.cpp
@@ -44,8 +44,10 @@ test()
     static_assert((std::is_same<typename MR::string_type, std::basic_string<CharT> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
index 050680ae7..6b57a193a 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -44,4 +44,6 @@ int main()
         assert(sm.compare(string()) > 0);
         assert(sm.compare(string(L"123")) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
index 6e7d34d78..6d0976bbf 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -50,4 +50,6 @@ int main()
         sm2.matched = true;
         assert(sm.compare(sm2) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp b/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
index 672d4aa32..42e6ab94a 100644
--- a/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -42,4 +42,6 @@ int main()
         assert(sm.compare(L"") > 0);
         assert(sm.compare(L"123") == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.members/default.pass.cpp b/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
index a2473552e..c34591f22 100644
--- a/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -30,4 +30,6 @@ int main()
         SM sm;
         assert(sm.matched == false);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.members/length.pass.cpp b/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
index 459a8fe91..5246eb351 100644
--- a/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -40,4 +40,6 @@ int main()
         sm.matched = true;
         assert(sm.length() == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp b/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
index 47659e59c..051ecc3e8 100644
--- a/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -44,4 +44,6 @@ int main()
         str = sm;
         assert(str == std::wstring(L"123"));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.members/str.pass.cpp b/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
index c09783b80..af39ee9c3 100644
--- a/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -44,4 +44,6 @@ int main()
         str = sm.str();
         assert(str == std::wstring(L"123"));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp b/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
index ad65ec54d..e332a8379 100644
--- a/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
@@ -276,7 +276,7 @@ test(const std::basic_string<CharT>& x, const std::basic_string<CharT>& y, bool
     assert((sm1 >= y[0]) == (x >= string(1, y[0])));
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("123"), std::string("123"));
     test(std::string("1234"), std::string("123"));
@@ -284,4 +284,6 @@ int main()
     test(std::wstring(L"1234"), std::wstring(L"123"));
     test(std::string("123\000" "56", 6), std::string("123\000" "56", 6), false);
     test(std::wstring(L"123\000" L"56", 6), std::wstring(L"123\000" L"56", 6), false);
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp b/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
index 63c7d815c..070266d9e 100644
--- a/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
+++ b/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
@@ -35,8 +35,10 @@ test(const std::basic_string<CharT>& s)
     assert(os.str() == s);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("123"));
     test(std::wstring(L"123"));
+
+  return 0;
 }
diff --git a/test/std/re/re.submatch/types.pass.cpp b/test/std/re/re.submatch/types.pass.cpp
index 8141a5302..831eec1da 100644
--- a/test/std/re/re.submatch/types.pass.cpp
+++ b/test/std/re/re.submatch/types.pass.cpp
@@ -27,7 +27,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::sub_match<char*> SM;
@@ -61,4 +61,6 @@ int main()
         static_assert((std::is_same<std::ssub_match, std::sub_match<std::string::const_iterator> >::value), "");
         static_assert((std::is_same<std::wssub_match, std::sub_match<std::wstring::const_iterator> >::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/cmatch.pass.cpp b/test/std/re/re.syn/cmatch.pass.cpp
index 1e7149bb7..7b85a69a2 100644
--- a/test/std/re/re.syn/cmatch.pass.cpp
+++ b/test/std/re/re.syn/cmatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<const char*>, std::cmatch>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/cregex_iterator.pass.cpp b/test/std/re/re.syn/cregex_iterator.pass.cpp
index 15c7ea8cf..29fdadeb6 100644
--- a/test/std/re/re.syn/cregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/cregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<const char*>, std::cregex_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/cregex_token_iterator.pass.cpp b/test/std/re/re.syn/cregex_token_iterator.pass.cpp
index a5b1bc583..7ca531dfe 100644
--- a/test/std/re/re.syn/cregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/cregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<const char*>, std::cregex_token_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/csub_match.pass.cpp b/test/std/re/re.syn/csub_match.pass.cpp
index 7c3d644fd..2ace0b983 100644
--- a/test/std/re/re.syn/csub_match.pass.cpp
+++ b/test/std/re/re.syn/csub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<const char*>, std::csub_match>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/regex.pass.cpp b/test/std/re/re.syn/regex.pass.cpp
index 1fe91ec34..0b4c07b6f 100644
--- a/test/std/re/re.syn/regex.pass.cpp
+++ b/test/std/re/re.syn/regex.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::basic_regex<char>, std::regex>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/smatch.pass.cpp b/test/std/re/re.syn/smatch.pass.cpp
index bee9f9f0d..01fa1e955 100644
--- a/test/std/re/re.syn/smatch.pass.cpp
+++ b/test/std/re/re.syn/smatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<std::string::const_iterator>, std::smatch>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/sregex_iterator.pass.cpp b/test/std/re/re.syn/sregex_iterator.pass.cpp
index a691cc799..1ae462c6b 100644
--- a/test/std/re/re.syn/sregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/sregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<std::string::const_iterator>, std::sregex_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/sregex_token_iterator.pass.cpp b/test/std/re/re.syn/sregex_token_iterator.pass.cpp
index 6d148280d..4b67b66f2 100644
--- a/test/std/re/re.syn/sregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/sregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<std::string::const_iterator>, std::sregex_token_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/ssub_match.pass.cpp b/test/std/re/re.syn/ssub_match.pass.cpp
index 0730d667e..fe3312968 100644
--- a/test/std/re/re.syn/ssub_match.pass.cpp
+++ b/test/std/re/re.syn/ssub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<std::string::const_iterator>, std::ssub_match>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wcmatch.pass.cpp b/test/std/re/re.syn/wcmatch.pass.cpp
index 4c9b7e1f2..f373e57ac 100644
--- a/test/std/re/re.syn/wcmatch.pass.cpp
+++ b/test/std/re/re.syn/wcmatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<const wchar_t*>, std::wcmatch>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wcregex_iterator.pass.cpp b/test/std/re/re.syn/wcregex_iterator.pass.cpp
index c81aa78c1..3425c98fe 100644
--- a/test/std/re/re.syn/wcregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/wcregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<const wchar_t*>, std::wcregex_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wcregex_token_iterator.pass.cpp b/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
index 9d407103a..217653837 100644
--- a/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<const wchar_t*>, std::wcregex_token_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wcsub_match.pass.cpp b/test/std/re/re.syn/wcsub_match.pass.cpp
index 7f18b272f..86a2103b8 100644
--- a/test/std/re/re.syn/wcsub_match.pass.cpp
+++ b/test/std/re/re.syn/wcsub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<const wchar_t*>, std::wcsub_match>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wregex.pass.cpp b/test/std/re/re.syn/wregex.pass.cpp
index 9622b89d6..5be6f6fb5 100644
--- a/test/std/re/re.syn/wregex.pass.cpp
+++ b/test/std/re/re.syn/wregex.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::basic_regex<wchar_t>, std::wregex>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wsmatch.pass.cpp b/test/std/re/re.syn/wsmatch.pass.cpp
index 98bcbdc4d..760057e6a 100644
--- a/test/std/re/re.syn/wsmatch.pass.cpp
+++ b/test/std/re/re.syn/wsmatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<std::wstring::const_iterator>, std::wsmatch>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wsregex_iterator.pass.cpp b/test/std/re/re.syn/wsregex_iterator.pass.cpp
index 1f733d905..b1d7edf87 100644
--- a/test/std/re/re.syn/wsregex_iterator.pass.cpp
+++ b/test/std/re/re.syn/wsregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<std::wstring::const_iterator>, std::wsregex_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wsregex_token_iterator.pass.cpp b/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
index b65e41345..58454a59e 100644
--- a/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
+++ b/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<std::wstring::const_iterator>, std::wsregex_token_iterator>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.syn/wssub_match.pass.cpp b/test/std/re/re.syn/wssub_match.pass.cpp
index 8f82b34d2..7ca6dc773 100644
--- a/test/std/re/re.syn/wssub_match.pass.cpp
+++ b/test/std/re/re.syn/wssub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<std::wstring::const_iterator>, std::wssub_match>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/default.pass.cpp b/test/std/re/re.traits/default.pass.cpp
index b49cc8647..459f044e0 100644
--- a/test/std/re/re.traits/default.pass.cpp
+++ b/test/std/re/re.traits/default.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t1;
@@ -36,4 +36,6 @@ int main()
         std::regex_traits<wchar_t> t2;
         assert(t2.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/getloc.pass.cpp b/test/std/re/re.traits/getloc.pass.cpp
index 82e804dc6..dbc35dec3 100644
--- a/test/std/re/re.traits/getloc.pass.cpp
+++ b/test/std/re/re.traits/getloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t1;
@@ -35,4 +35,6 @@ int main()
         std::regex_traits<wchar_t> t2;
         assert(t2.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/imbue.pass.cpp b/test/std/re/re.traits/imbue.pass.cpp
index d2343f271..0200ce01e 100644
--- a/test/std/re/re.traits/imbue.pass.cpp
+++ b/test/std/re/re.traits/imbue.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -29,4 +29,6 @@ int main()
         assert(loc.name() == "C");
         assert(t.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/isctype.pass.cpp b/test/std/re/re.traits/isctype.pass.cpp
index a2f9e2b93..1eed193ae 100644
--- a/test/std/re/re.traits/isctype.pass.cpp
+++ b/test/std/re/re.traits/isctype.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -280,4 +280,6 @@ int main()
         assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
         assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/length.pass.cpp b/test/std/re/re.traits/length.pass.cpp
index 822f781ab..dce6284bc 100644
--- a/test/std/re/re.traits/length.pass.cpp
+++ b/test/std/re/re.traits/length.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_traits<char>::length("") == 0);
     assert(std::regex_traits<char>::length("1") == 1);
@@ -28,4 +28,6 @@ int main()
     assert(std::regex_traits<wchar_t>::length(L"1") == 1);
     assert(std::regex_traits<wchar_t>::length(L"12") == 2);
     assert(std::regex_traits<wchar_t>::length(L"123") == 3);
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/lookup_classname.pass.cpp b/test/std/re/re.traits/lookup_classname.pass.cpp
index 74207a019..38bafa67e 100644
--- a/test/std/re/re.traits/lookup_classname.pass.cpp
+++ b/test/std/re/re.traits/lookup_classname.pass.cpp
@@ -53,7 +53,7 @@ test_w(const char_type* A,
       assert(!matches_underscore && "should not match underscore");
 }
 
-int main()
+int main(int, char**)
 {
 //  if __regex_word is not distinct from all the classes, bad things happen
 //  See https://bugs.llvm.org/show_bug.cgi?id=26476 for an example.
@@ -243,4 +243,6 @@ int main()
     test(L"dig", std::ctype_base::mask());
     test(L"", std::ctype_base::mask());
     test(L"digits", std::ctype_base::mask());
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/lookup_collatename.pass.cpp b/test/std/re/re.traits/lookup_collatename.pass.cpp
index 3e1fd860a..aeb7c50bb 100644
--- a/test/std/re/re.traits/lookup_collatename.pass.cpp
+++ b/test/std/re/re.traits/lookup_collatename.pass.cpp
@@ -39,7 +39,7 @@ test(const char_type* A, const std::basic_string<char_type>& expected)
     assert(t.lookup_collatename(F(A), F(A + t.length(A))) == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test("NUL", std::string("\x00", 1));
     test("alert", std::string("\x07"));
@@ -192,4 +192,6 @@ int main()
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     test(L"ch", std::wstring(L"ch"));
     std::locale::global(std::locale("C"));
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/transform.pass.cpp b/test/std/re/re.traits/transform.pass.cpp
index 75a6c40c7..0125d419e 100644
--- a/test/std/re/re.traits/transform.pass.cpp
+++ b/test/std/re/re.traits/transform.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -45,4 +45,6 @@ int main()
         t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
         assert(t.transform(F(a), F(a+1)) < t.transform(F(B), F(B+1)));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/transform_primary.pass.cpp b/test/std/re/re.traits/transform_primary.pass.cpp
index b2dab418a..e24125e06 100644
--- a/test/std/re/re.traits/transform_primary.pass.cpp
+++ b/test/std/re/re.traits/transform_primary.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -51,4 +51,6 @@ int main()
         assert(t.transform_primary(F(A), F(A+1)) ==
                t.transform_primary(F(Aacute), F(Aacute+1)));
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/translate.pass.cpp b/test/std/re/re.traits/translate.pass.cpp
index 96c77f97c..e56af4df3 100644
--- a/test/std/re/re.traits/translate.pass.cpp
+++ b/test/std/re/re.traits/translate.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -31,4 +31,6 @@ int main()
         assert(t.translate(L'B') == L'B');
         assert(t.translate(L'c') == L'c');
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/translate_nocase.pass.cpp b/test/std/re/re.traits/translate_nocase.pass.cpp
index 893c0cd28..6e9f01d16 100644
--- a/test/std/re/re.traits/translate_nocase.pass.cpp
+++ b/test/std/re/re.traits/translate_nocase.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -61,4 +61,6 @@ int main()
         assert(t.translate_nocase(L'\xDA') == L'\xFA');
         assert(t.translate_nocase(L'\xFA') == L'\xFA');
     }
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/types.pass.cpp b/test/std/re/re.traits/types.pass.cpp
index 0d7a2f29b..c3a8770f0 100644
--- a/test/std/re/re.traits/types.pass.cpp
+++ b/test/std/re/re.traits/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_traits<char>::char_type, char>::value), "");
     static_assert((std::is_same<std::regex_traits<char>::string_type, std::string>::value), "");
@@ -29,4 +29,6 @@ int main()
     static_assert((std::is_same<std::regex_traits<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::regex_traits<wchar_t>::string_type, std::wstring>::value), "");
     static_assert((std::is_same<std::regex_traits<wchar_t>::locale_type, std::locale>::value), "");
+
+  return 0;
 }
diff --git a/test/std/re/re.traits/value.pass.cpp b/test/std/re/re.traits/value.pass.cpp
index 89bf9c352..b7ca1fb7c 100644
--- a/test/std/re/re.traits/value.pass.cpp
+++ b/test/std/re/re.traits/value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -122,4 +122,6 @@ int main()
             assert(t.value(c, 16) == -1);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp b/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
index 10504c501..0fecb1bb0 100644
--- a/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
+++ b/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::string>();
@@ -30,4 +30,6 @@ int main() {
     test_hash_enabled_for_type<std::u32string>();
 #endif
   }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.hash/strings.pass.cpp b/test/std/strings/basic.string.hash/strings.pass.cpp
index ea97e64f2..c2a2ef956 100644
--- a/test/std/strings/basic.string.hash/strings.pass.cpp
+++ b/test/std/strings/basic.string.hash/strings.pass.cpp
@@ -40,7 +40,7 @@ test()
     assert(h(s1) != h(s2));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string>();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -51,4 +51,6 @@ int main()
     test<std::u32string>();
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::wstring>();
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.literals/literal.pass.cpp b/test/std/strings/basic.string.literals/literal.pass.cpp
index eed5c9420..a51d0d9ac 100644
--- a/test/std/strings/basic.string.literals/literal.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_literals;
 
@@ -54,4 +54,6 @@ int main()
     Lfoo  =  L"ABC"s;     assert( Lfoo ==  L"ABC");   assert( Lfoo == std::wstring  ( L"ABC"));
     ufoo  =  u"ABC"s;     assert( ufoo ==  u"ABC");   assert( ufoo == std::u16string( u"ABC"));
     Ufoo  =  U"ABC"s;     assert( Ufoo ==  U"ABC");   assert( Ufoo == std::u32string( U"ABC"));
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.literals/literal1.fail.cpp b/test/std/strings/basic.string.literals/literal1.fail.cpp
index 129d28447..be4604059 100644
--- a/test/std/strings/basic.string.literals/literal1.fail.cpp
+++ b/test/std/strings/basic.string.literals/literal1.fail.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::string;
 
     string foo  =   ""s;  // should fail w/conversion operator not found
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.literals/literal1.pass.cpp b/test/std/strings/basic.string.literals/literal1.pass.cpp
index 5134ec79a..92777c4f4 100644
--- a/test/std/strings/basic.string.literals/literal1.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal1.pass.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
     std::string foo  =   ""s;
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.literals/literal2.fail.cpp b/test/std/strings/basic.string.literals/literal2.fail.cpp
index 3ebbfa24c..54a0a9e40 100644
--- a/test/std/strings/basic.string.literals/literal2.fail.cpp
+++ b/test/std/strings/basic.string.literals/literal2.fail.cpp
@@ -12,7 +12,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string foo  =   ""s;  // should fail w/conversion operator not found
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.literals/literal2.pass.cpp b/test/std/strings/basic.string.literals/literal2.pass.cpp
index ac41ce94c..6f73ae9a1 100644
--- a/test/std/strings/basic.string.literals/literal2.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal2.pass.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_literals;
 
     std::string foo  =   ""s;
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string.literals/literal3.pass.cpp b/test/std/strings/basic.string.literals/literal3.pass.cpp
index c5ca6708a..b7a8d5536 100644
--- a/test/std/strings/basic.string.literals/literal3.pass.cpp
+++ b/test/std/strings/basic.string.literals/literal3.pass.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std;
 
     string foo  =   ""s;
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/allocator_mismatch.fail.cpp b/test/std/strings/basic.string/allocator_mismatch.fail.cpp
index ae63acfce..1d016991f 100644
--- a/test/std/strings/basic.string/allocator_mismatch.fail.cpp
+++ b/test/std/strings/basic.string/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::basic_string<char, std::char_traits<char>, std::allocator<int> > s;
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/char.bad.fail.cpp b/test/std/strings/basic.string/char.bad.fail.cpp
index d78cb6aad..bace91c32 100644
--- a/test/std/strings/basic.string/char.bad.fail.cpp
+++ b/test/std/strings/basic.string/char.bad.fail.cpp
@@ -26,7 +26,7 @@ private:
     int two;
 };
 
-int main()
+int main(int, char**)
 {
     {
 //  array
@@ -49,4 +49,6 @@ int main()
     std::basic_string<NotStandardLayout, test_traits<NotStandardLayout> > s;
 //  expected-error-re@string:* {{static_assert failed{{.*}} "Character type of basic_string must be standard-layout"}}
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.access/at.pass.cpp b/test/std/strings/basic.string/string.access/at.pass.cpp
index 6515e2727..514d1a894 100644
--- a/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -54,7 +54,7 @@ test(S s, typename S::size_type pos)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -74,4 +74,6 @@ int main()
     test(S("123"), 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.access/back.pass.cpp b/test/std/strings/basic.string/string.access/back.pass.cpp
index b4108010a..3831da084 100644
--- a/test/std/strings/basic.string/string.access/back.pass.cpp
+++ b/test/std/strings/basic.string/string.access/back.pass.cpp
@@ -31,7 +31,7 @@ test(S s)
     assert(s.back() == typename S::value_type('z'));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -52,4 +52,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.access/db_back.pass.cpp b/test/std/strings/basic.string/string.access/db_back.pass.cpp
index 5034bfa11..e1cf707a6 100644
--- a/test/std/strings/basic.string/string.access/db_back.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_back.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.access/db_cback.pass.cpp b/test/std/strings/basic.string/string.access/db_cback.pass.cpp
index ddffb6cd7..e3e6db525 100644
--- a/test/std/strings/basic.string/string.access/db_cback.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cback.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -42,8 +42,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.access/db_cfront.pass.cpp b/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
index e171883dc..c9b2ba7c8 100644
--- a/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cfront.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -42,8 +42,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.access/db_cindex.pass.cpp b/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
index 770ab333c..c7b430efc 100644
--- a/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_cindex.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.access/db_front.pass.cpp b/test/std/strings/basic.string/string.access/db_front.pass.cpp
index 7f2db649a..73db22405 100644
--- a/test/std/strings/basic.string/string.access/db_front.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_front.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.access/db_index.pass.cpp b/test/std/strings/basic.string/string.access/db_index.pass.cpp
index 40318e398..d3f2e8d28 100644
--- a/test/std/strings/basic.string/string.access/db_index.pass.cpp
+++ b/test/std/strings/basic.string/string.access/db_index.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.access/front.pass.cpp b/test/std/strings/basic.string/string.access/front.pass.cpp
index 5eee328fe..d51a12f0a 100644
--- a/test/std/strings/basic.string/string.access/front.pass.cpp
+++ b/test/std/strings/basic.string/string.access/front.pass.cpp
@@ -31,7 +31,7 @@ test(S s)
     assert(s.front() == typename S::value_type('z'));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -52,4 +52,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.access/index.pass.cpp b/test/std/strings/basic.string/string.access/index.pass.cpp
index d529567c6..3a1224ca3 100644
--- a/test/std/strings/basic.string/string.access/index.pass.cpp
+++ b/test/std/strings/basic.string/string.access/index.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -59,4 +59,6 @@ int main()
         assert(false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/capacity.pass.cpp b/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
index 9f09dea1d..02187c519 100644
--- a/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/capacity.pass.cpp
@@ -40,7 +40,7 @@ test(S s)
     S::allocator_type::throw_after = INT_MAX;
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
@@ -60,4 +60,6 @@ int main()
     assert(s.capacity() > 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/clear.pass.cpp b/test/std/strings/basic.string/string.capacity/clear.pass.cpp
index 4f75e0134..914842bb7 100644
--- a/test/std/strings/basic.string/string.capacity/clear.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/clear.pass.cpp
@@ -23,7 +23,7 @@ test(S s)
     assert(s.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -53,4 +53,6 @@ int main()
     test(s);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/empty.fail.cpp b/test/std/strings/basic.string/string.capacity/empty.fail.cpp
index 2359dea94..1bfa388b7 100644
--- a/test/std/strings/basic.string/string.capacity/empty.fail.cpp
+++ b/test/std/strings/basic.string/string.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::string c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/empty.pass.cpp b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
index 56d925d57..47827db7f 100644
--- a/test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -24,7 +24,7 @@ test(const S& s)
     assert(s.empty() == (s.size() == 0));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -40,4 +40,6 @@ int main()
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/length.pass.cpp b/test/std/strings/basic.string/string.capacity/length.pass.cpp
index 617d81a92..b61ec488e 100644
--- a/test/std/strings/basic.string/string.capacity/length.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/length.pass.cpp
@@ -22,7 +22,7 @@ test(const S& s)
     assert(s.length() == s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -38,4 +38,6 @@ int main()
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/max_size.pass.cpp b/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
index 68017f453..8f8c9a3fb 100644
--- a/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/max_size.pass.cpp
@@ -54,7 +54,7 @@ test(const S& s)
     test2(s);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -70,4 +70,6 @@ int main()
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp b/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
index 414b67424..9832df536 100644
--- a/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
@@ -35,7 +35,7 @@ test(const S& s)
     assert ( false );
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -51,4 +51,6 @@ int main()
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/reserve.pass.cpp b/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
index 33699a799..f49125cec 100644
--- a/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/reserve.pass.cpp
@@ -65,7 +65,7 @@ test(S s, typename S::size_type res_arg)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -131,4 +131,6 @@ int main()
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp b/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
index ad37dc30a..8b545939e 100644
--- a/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
@@ -43,7 +43,7 @@ test(S s, typename S::size_type n, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@ int main()
     test(S(), S::npos, S("not going to happen"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp b/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
index b90053414..b5e5aff84 100644
--- a/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
@@ -43,7 +43,7 @@ test(S s, typename S::size_type n, typename S::value_type c, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@ int main()
     test(S(), S::npos, 'a', S("not going to happen"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp b/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
index ee91ac167..2c6ce0df6 100644
--- a/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
@@ -29,7 +29,7 @@ test(S s)
     assert(s.capacity() >= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -59,4 +59,6 @@ int main()
     test(s);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.capacity/size.pass.cpp b/test/std/strings/basic.string/string.capacity/size.pass.cpp
index 16b236eeb..f3f89a5a6 100644
--- a/test/std/strings/basic.string/string.capacity/size.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/size.pass.cpp
@@ -22,7 +22,7 @@ test(const S& s, typename S::size_type c)
     assert(s.size() == c);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -38,4 +38,6 @@ int main()
     test(S("12345678901234567890123456789012345678901234567890"), 50);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp b/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
index 4f8158ea5..38725979f 100644
--- a/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
@@ -91,7 +91,7 @@ test(SV sv, std::size_t pos, std::size_t n, const typename S::allocator_type& a)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -183,4 +183,6 @@ int main()
     S s7(s.data(), 2);     // calls ctor(const char *, len)
     assert(s7 == "AB");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/alloc.pass.cpp b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
index a2518a184..765f61eaf 100644
--- a/test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -85,11 +85,13 @@ test2()
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #if TEST_STD_VER >= 11
     test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
     test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
index 44db3c140..5e77e46b2 100644
--- a/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   // Test that assignment from {} and {ptr, len} are allowed and are not
   // ambiguous.
@@ -32,4 +32,6 @@ int main()
     s = {"abc", 2};
     assert(s == "ab");
   }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
index e3976cffa..53f676e3b 100644
--- a/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
@@ -28,7 +28,7 @@ test(S s1, typename S::value_type s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -46,4 +46,6 @@ int main()
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/copy.pass.cpp b/test/std/strings/basic.string/string.cons/copy.pass.cpp
index f2cfa8a0e..0024f2def 100644
--- a/test/std/strings/basic.string/string.cons/copy.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy.pass.cpp
@@ -28,7 +28,7 @@ test(S s1)
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -46,4 +46,6 @@ int main()
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
index 57a17e8ab..a635f017e 100644
--- a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -87,7 +87,7 @@ test(S s1, const typename S::allocator_type& a)
     assert(s2.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -127,4 +127,6 @@ int main()
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
index a3c1389da..8b3b7ac04 100644
--- a/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
@@ -27,7 +27,7 @@ test(S s1, const S& s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -76,4 +76,6 @@ int main()
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
index 1ab00b60e..301876b2c 100644
--- a/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -35,4 +35,6 @@ int main()
         typedef std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
index 5b57fe3ca..d1372d296 100644
--- a/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
@@ -32,7 +32,7 @@ struct throwing_alloc
 std::string s;
 std::wstring ws;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -48,4 +48,6 @@ int main()
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp b/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
index 7eb364e62..9e31d3e6f 100644
--- a/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
@@ -46,7 +46,7 @@ using BStr = std::basic_string<T, std::char_traits<T>, Alloc>;
 // (13) basic_string(initializer_list<CharT>, A const& = A())
 // (14) basic_string(BSV, A const& = A())
 // (15) basic_string(const T&, size_type, size_type, A const& = A())
-int main()
+int main(int, char**)
 {
   using TestSizeT = test_allocator<char>::size_type;
   { // Testing (1)
@@ -313,4 +313,6 @@ int main()
     ASSERT_SAME_TYPE(decltype(w), ExpectW);
     assert(w == L"cd");
   }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp b/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
index 3a8914cd3..a106203d4 100644
--- a/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s = {'a', 'b', 'c'};
@@ -40,4 +40,6 @@ int main()
         s = {L'a', L'b', L'c'};
         assert(s == L"abc");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
index 6a512f274..dcb9bb911 100644
--- a/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s;
@@ -30,4 +30,6 @@ int main()
         s = {'a', 'b', 'c'};
         assert(s == "abc");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
index 6966e6e5d..042018cb5 100644
--- a/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -56,7 +56,7 @@ test(It first, It last, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -116,4 +116,6 @@ int main()
     test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
index f87aac5f0..57fd550ac 100644
--- a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
@@ -35,7 +35,7 @@ class NotAnItertor {};
 template <typename T>
 struct NotAnAllocator { typedef T value_type; };
 
-int main()
+int main(int, char**)
 {
     { // Not an iterator at all
     std::basic_string s1{NotAnItertor{}, NotAnItertor{}, std::allocator<char>{}}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
@@ -52,4 +52,6 @@ int main()
     std::basic_string s1{s, s+10, NotAnAllocator<wchar_t>{}}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
     }
 
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
index dac9ee332..44daab4fc 100644
--- a/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
@@ -36,7 +36,7 @@
 #include "../input_iterator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "12345678901234";
@@ -89,4 +89,6 @@ int main()
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/move.pass.cpp b/test/std/strings/basic.string/string.cons/move.pass.cpp
index 1c11368c7..729c8e806 100644
--- a/test/std/strings/basic.string/string.cons/move.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move.pass.cpp
@@ -32,7 +32,7 @@ test(S s0)
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -48,4 +48,6 @@ int main()
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
index e426e2dc8..63e349e71 100644
--- a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -34,7 +34,7 @@ test(S s0, const typename S::allocator_type& a)
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -74,4 +74,6 @@ int main()
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
index 88bc12310..2a00898c1 100644
--- a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
@@ -62,7 +62,7 @@ struct some_alloc3
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -93,4 +93,6 @@ int main()
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
index b039e7955..9684fe738 100644
--- a/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
@@ -32,7 +32,7 @@ test(S s1, S s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -70,4 +70,6 @@ int main()
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
index 374183f99..ee839cf26 100644
--- a/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -39,4 +39,6 @@ int main()
         static_assert( std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
index b68c5228a..d67f1231f 100644
--- a/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -51,7 +51,7 @@ test(const charT* s, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -85,4 +85,6 @@ int main()
     test("123456798012345679801234567980123456798012345679801234567980", A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
index 1216f3f18..4a885485b 100644
--- a/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
@@ -29,7 +29,7 @@ test(S s1, const typename S::value_type* s2)
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -69,4 +69,6 @@ int main()
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
index 96457135e..75ad883fc 100644
--- a/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -48,7 +48,7 @@ test(const charT* s, unsigned n, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -90,4 +90,6 @@ int main()
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
index 21ed485ef..d50997191 100644
--- a/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -80,7 +80,7 @@ test(Tp n, Tp c, const A& a)
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -120,4 +120,6 @@ int main()
     test(static_cast<char>(100), static_cast<char>(65), A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view.fail.cpp b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
index d7a054073..61d5b3db4 100644
--- a/test/std/strings/basic.string/string.cons/string_view.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
@@ -15,8 +15,10 @@
 
 void foo ( const string &s ) {}
 
-int main()
+int main(int, char**)
 {
     std::string_view sv = "ABCDE";
     foo(sv);    // requires implicit conversion from string_view to string
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view.pass.cpp b/test/std/strings/basic.string/string.cons/string_view.pass.cpp
index f50d9e519..b423c327d 100644
--- a/test/std/strings/basic.string/string.cons/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view.pass.cpp
@@ -71,7 +71,7 @@ test(std::basic_string_view<charT> sv, const A& a)
   }
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -107,4 +107,6 @@ int main()
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
index 9a50f62a7..942d990ee 100644
--- a/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
@@ -28,7 +28,7 @@ test(S s1, SV sv)
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -70,4 +70,6 @@ int main()
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp b/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
index 23e6668e6..62ce16eca 100644
--- a/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
@@ -31,10 +31,12 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 23}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
index ee731581f..b3adc4146 100644
--- a/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
@@ -38,7 +38,7 @@
 #include "../input_iterator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
@@ -103,4 +103,6 @@ int main()
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
index ce4e69537..cff605677 100644
--- a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
@@ -37,10 +37,12 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4, 23}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
index daba3bd12..983ab78e4 100644
--- a/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
@@ -42,7 +42,7 @@
 #include "../input_iterator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
@@ -107,4 +107,6 @@ int main()
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.cons/substr.pass.cpp b/test/std/strings/basic.string/string.cons/substr.pass.cpp
index 05c53ac23..44f29beec 100644
--- a/test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -140,7 +140,7 @@ void test2583()
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -224,4 +224,6 @@ int main()
     test2583();
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
index 7d1c26418..e2afe0420 100644
--- a/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -30,4 +30,6 @@ int main()
     assert ( s2.ends_with('e'));
     assert (!s2.ends_with('x'));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
index 87b94042f..a4f8b1aa3 100644
--- a/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -59,4 +59,6 @@ int main()
     assert (!sNot.ends_with("abcde"));
     assert ( sNot.ends_with("def"));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
index 3d75e23da..cbfffcfce 100644
--- a/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -68,4 +68,6 @@ int main()
     assert (!sNot.ends_with(sv5));
     assert ( sNot.ends_with(svNot));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/begin.pass.cpp b/test/std/strings/basic.string/string.iterators/begin.pass.cpp
index eedc9b991..fbae9fab7 100644
--- a/test/std/strings/basic.string/string.iterators/begin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/begin.pass.cpp
@@ -30,7 +30,7 @@ test(S s)
     assert(b == cb);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,4 +44,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
index 720ba53e7..9886d56bb 100644
--- a/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
@@ -27,7 +27,7 @@ test(const S& s)
     assert(cb == s.begin());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -41,4 +41,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/cend.pass.cpp b/test/std/strings/basic.string/string.iterators/cend.pass.cpp
index 07d885aee..1a3d30775 100644
--- a/test/std/strings/basic.string/string.iterators/cend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/cend.pass.cpp
@@ -23,7 +23,7 @@ test(const S& s)
     assert(ce == s.end());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -37,4 +37,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
index 2b8837fd3..687c34368 100644
--- a/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
@@ -27,7 +27,7 @@ test(const S& s)
     assert(cb == s.rbegin());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -41,4 +41,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/crend.pass.cpp b/test/std/strings/basic.string/string.iterators/crend.pass.cpp
index c74b907fe..86aaad699 100644
--- a/test/std/strings/basic.string/string.iterators/crend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/crend.pass.cpp
@@ -23,7 +23,7 @@ test(const S& s)
     assert(ce == s.rend());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -37,4 +37,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
index 074fa84bd..469632394 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
index 9c63eeafe..7dbbbbb4c 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
index c01b22662..1a46f86c2 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -46,8 +46,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
index a5a8d917b..77caf1b81 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -50,8 +50,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
index b4c7fb380..126c3661c 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -48,8 +48,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
index 6a262e0f3..f1083a439 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -48,8 +48,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp b/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
index f3b5656f7..c69f8ca4b 100644
--- a/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -44,8 +44,10 @@ int main()
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
diff --git a/test/std/strings/basic.string/string.iterators/end.pass.cpp b/test/std/strings/basic.string/string.iterators/end.pass.cpp
index 8d287f6f7..86b00a370 100644
--- a/test/std/strings/basic.string/string.iterators/end.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/end.pass.cpp
@@ -33,7 +33,7 @@ test(S s)
     assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -47,4 +47,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/iterators.pass.cpp b/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
index 3d9076023..08448b1fd 100644
--- a/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/iterators.pass.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     { // N3644 testing
         typedef std::string C;
@@ -83,4 +83,6 @@ int main()
         assert ( !(ii1 != ii2 ));
         assert ( !(ii1 != cii ));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp b/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
index 8de45475f..479584c37 100644
--- a/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
@@ -30,7 +30,7 @@ test(S s)
     assert(b == cb);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,4 +44,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.iterators/rend.pass.cpp b/test/std/strings/basic.string/string.iterators/rend.pass.cpp
index 1edcb27af..9b54058a6 100644
--- a/test/std/strings/basic.string/string.iterators/rend.pass.cpp
+++ b/test/std/strings/basic.string/string.iterators/rend.pass.cpp
@@ -33,7 +33,7 @@ test(S s)
     assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -47,4 +47,6 @@ int main()
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp b/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
index f2848295b..437524063 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
@@ -71,7 +71,7 @@ test_npos(S s, SV sv, typename S::size_type pos, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -196,4 +196,6 @@ int main()
     s.append(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
index 04483865d..da74fb4e0 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123");
@@ -31,4 +31,6 @@ int main()
         s.append({'a', 'b', 'c'});
         assert(s == "123abc");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
index 08f554b34..8f280e828 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -42,7 +42,7 @@ test_exceptions(S s, It first, It last)
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -219,4 +219,6 @@ int main()
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
index dec79a67c..eba693d0e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -26,7 +26,7 @@ test(S s, const typename S::value_type* str, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -76,4 +76,6 @@ int main()
     s_long.append(s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
index 2fb973ae9..c214ab7c2 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -27,7 +27,7 @@ test(S s, const typename S::value_type* str, typename S::size_type n, S expected
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@ int main()
     s_long.append(s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
index a2b9ad1e4..f1b34ad6c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -31,7 +31,7 @@ test(S s, typename S::value_type c, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -56,4 +56,6 @@ int main()
     s.push_back(vl);
     s.push_back(vl);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
index 59d0199a2..c40624892 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
@@ -26,7 +26,7 @@ test(S s, typename S::size_type n, typename S::value_type c, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -60,4 +60,6 @@ int main()
     test(S("12345678901234567890"), 10, 'a', S("12345678901234567890aaaaaaaaaa"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
index c0c625f2e..5e551d7a2 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
@@ -26,7 +26,7 @@ test(S s, S str, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@ int main()
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
index 21ddd9bb2..37985d001 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
@@ -71,7 +71,7 @@ test_npos(S s, S str, typename S::size_type pos, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -133,4 +133,6 @@ int main()
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
index 301fc77b7..d0fb1cc33 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
@@ -27,7 +27,7 @@ test(S s, SV sv, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -79,4 +79,6 @@ int main()
          S("1234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
index b05417122..044b37240 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
@@ -70,7 +70,7 @@ test_npos(S s, SV sv, typename S::size_type pos, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -191,4 +191,6 @@ int main()
     s.assign(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
index 72097dae6..692b84b55 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123");
@@ -31,4 +31,6 @@ int main()
         s.assign({'a', 'b', 'c'});
         assert(s == "abc");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
index 4bf805c99..c03b5efdf 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -43,7 +43,7 @@ test_exceptions(S s, It first, It last)
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -204,4 +204,6 @@ int main()
     s.assign(p, p + 4);
     assert(s == "ABCD");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
index 62a173a18..325c354c5 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -26,7 +26,7 @@ test(S s, const typename S::value_type* str, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -74,4 +74,6 @@ int main()
     s_long.assign(s_long.c_str() + 30);
     assert(s_long == "nsectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
index 442d8c000..5d3fe2621 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -27,7 +27,7 @@ test(S s, const typename S::value_type* str, typename S::size_type n, S expected
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@ int main()
     s_long.assign(s_long.data() + 2, 8 );
     assert(s_long == "rem ipsu");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
index 3d401c8a9..ac26f369d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
@@ -27,7 +27,7 @@ test(S s, S str, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -77,4 +77,6 @@ int main()
          S("12345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
index 8c69b138f..4e5ecad2e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
@@ -26,7 +26,7 @@ test(S s, typename S::size_type n, typename S::value_type c, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -60,4 +60,6 @@ int main()
     test(S("12345678901234567890"), 10, 'a', S(10, 'a'));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
index 274703a56..fae45c80d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
@@ -37,7 +37,7 @@ testAlloc(S s, S str, const typename S::allocator_type& a)
     assert(s.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -113,4 +113,6 @@ int main()
     static_assert(noexcept(S().assign(S())), "");  // LWG#2063
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
index 76dd27345..8e11b150e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
@@ -71,7 +71,7 @@ test_npos(S s, S str, typename S::size_type pos, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -133,4 +133,6 @@ int main()
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
index d445ad9b7..2d1158e41 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
@@ -38,7 +38,7 @@ testAlloc(S s, SV sv, const typename S::allocator_type& a)
     assert(s.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -101,4 +101,6 @@ int main()
     testAlloc(S(), SV("12345678901234567890"), min_allocator<char>());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
index 81dc3329c..778fb70c0 100644
--- a/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
@@ -49,7 +49,7 @@ test(S str, typename S::value_type* s, typename S::size_type n,
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -177,4 +177,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), s, 21, 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
index 1923c62b4..12b13d738 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
@@ -28,7 +28,7 @@ test(S s, typename S::difference_type pos, S expected)
     assert(i - s.begin() == pos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -62,4 +62,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
index 0eba9361d..a5e6d1251 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
@@ -29,7 +29,7 @@ test(S s, typename S::difference_type pos, typename S::difference_type n, S expe
     assert(i - s.begin() == pos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -147,4 +147,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
index e6f2a4e60..e6490abcd 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
@@ -26,7 +26,7 @@ test(S s, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -42,4 +42,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
index a8e31c9c6..88dace52f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
@@ -88,7 +88,7 @@ test(S s, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -298,4 +298,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S(""));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
index d570428c0..ef6144dad 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
@@ -32,7 +32,7 @@ test(S& s, typename S::const_iterator p, typename S::value_type c, S expected)
         assert(i == p);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -72,4 +72,6 @@ int main()
     test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
index 0acc50b45..6dd043c6d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123456");
@@ -33,4 +33,6 @@ int main()
         assert(i - s.begin() == 3);
         assert(s == "123abc456");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
index c1b168729..6d4f1a668 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -49,7 +49,7 @@ test_exceptions(S s, typename S::difference_type pos, It first, It last)
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -218,4 +218,6 @@ int main()
     s.insert(s.begin(), MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
index ac29e3b33..699b67924 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
@@ -28,7 +28,7 @@ test(S s, typename S::difference_type pos, typename S::size_type n,
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -166,4 +166,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
index fb8c7e63a..2b54b6720 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
@@ -1729,7 +1729,7 @@ void test30()
     test_npos(S("abcdefghijklmnopqrst"), 10, SV("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1838,4 +1838,6 @@ int main()
     assert(s == "");
     s.clear();
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
index ee7ef204a..24859fa8b 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -47,7 +47,7 @@ test(S s, typename S::size_type pos, const typename S::value_type* str, S expect
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -233,4 +233,6 @@ int main()
     s_long.insert(0, s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
index 67a034005..3dbd93f1d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -48,7 +48,7 @@ test(S s, typename S::size_type pos, const typename S::value_type* str,
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -714,4 +714,6 @@ int main()
     s_long.insert(0, s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
index e64e9c997..dce8b7d7e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
@@ -48,7 +48,7 @@ test(S s, typename S::size_type pos, typename S::size_type n,
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -218,4 +218,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), 21, 20, '1', S("can't happen"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
index 2f74fec3f..93bc3f6d9 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
@@ -47,7 +47,7 @@ test(S s, typename S::size_type pos, S str, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -226,4 +226,6 @@ int main()
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
index 23b8852b4..18a688a5d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
@@ -1727,7 +1727,7 @@ void test30()
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1799,4 +1799,6 @@ int main()
     test30<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
index 0596ce984..129389a9a 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -47,7 +47,7 @@ test(S s, typename S::size_type pos, SV sv, S expected)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -235,4 +235,6 @@ int main()
     s_long.insert(0, s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
index 3c15f6f91..2cc4496eb 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
@@ -25,7 +25,7 @@ test(S s, typename S::value_type str, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -43,4 +43,6 @@ int main()
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
index 7f27559f0..689389eb7 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123");
@@ -30,4 +30,6 @@ int main()
         s += {'a', 'b', 'c'};
         assert(s == "123abc");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
index 3a7696935..a9edf17be 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
@@ -25,7 +25,7 @@ test(S s, const typename S::value_type* str, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -75,4 +75,6 @@ int main()
          S("1234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
index 53e1cacf4..f81d4bec0 100644
--- a/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
@@ -26,7 +26,7 @@ test(S s, S str, S expected)
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@ int main()
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
index 8e8a1f8ef..3df49f325 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123def456");
@@ -30,4 +30,6 @@ int main()
         s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
         assert(s == "123abc456");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
index fc6f33bea..47a1193be 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -963,7 +963,7 @@ void test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+20, S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1036,4 +1036,6 @@ int main()
     s.replace(s.begin(), s.end(), p, p + 4);
     assert(s == "EFGH");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
index ccbd0ff66..8ed1dc3df 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
@@ -265,7 +265,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -297,4 +297,6 @@ int main()
     s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
index 79ae58fce..39b518c91 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -943,7 +943,7 @@ void test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 20, S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -987,4 +987,6 @@ int main()
     s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
index 8a79b733f..e60c69f7a 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
@@ -265,7 +265,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 20, 0, 20, '3', S("abcdefghijklmnopqrst33333333333333333333"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -281,4 +281,6 @@ int main()
     test2<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
index b47d2931b..700873661 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
@@ -264,7 +264,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 20, 0, S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -289,4 +289,6 @@ int main()
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
index 81ecca69f..0acf82868 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
@@ -264,7 +264,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -282,4 +282,6 @@ int main()
     test2<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
index b320eff37..2348747de 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
@@ -5869,7 +5869,7 @@ void test55()
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -6025,4 +6025,6 @@ int main()
     s.replace(0, 4, arr, 0, std::string::npos);    // calls replace(pos1, n1, string("IJKL"), pos, npos)
     assert(s == "IJKL");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
index 6718242e0..a6a6c7d9d 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
@@ -363,7 +363,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -379,4 +379,6 @@ int main()
     test2<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
index 53465bf68..e30566707 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
@@ -1297,7 +1297,7 @@ void test11()
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", 20, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1331,4 +1331,6 @@ int main()
     test11<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
index 2e8c4527c..7d37e1075 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
@@ -364,7 +364,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 21, 0, 20, '2', S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -380,4 +380,6 @@ int main()
     test2<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
index 85306d595..c0fad33a3 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
@@ -362,7 +362,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -387,4 +387,6 @@ int main()
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
index 7a75f03e5..3fa32699f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -5859,7 +5859,7 @@ void test55()
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -5981,4 +5981,6 @@ int main()
     test55<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
index 9b35da025..542220aea 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
@@ -362,7 +362,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -380,4 +380,6 @@ int main()
     test2<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
index 79adee487..8fdf3fea9 100644
--- a/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
@@ -31,7 +31,7 @@ test(S s1, S s2)
     assert(s2 == s1_);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -73,4 +73,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp b/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
index 9937863b2..8e663cb4f 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream in(" abc\n  def\n   ghij");
@@ -77,4 +77,6 @@ int main()
         assert(s == L"   ghij");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
index 965137c1d..b081b55c9 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream in(" abc*  def**   ghij");
@@ -89,4 +89,6 @@ int main()
         assert(s == L"   ghij");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
index b2255d068..b1511f211 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("initial text");
@@ -45,4 +45,6 @@ int main()
         getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
         assert(s == L" abc");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
index a87529a0e..cf4772c43 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("initial text");
@@ -45,4 +45,6 @@ int main()
         getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
         assert(s == L" abc");
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
index 85f399dcd..389701d1d 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream in("a bc defghij");
@@ -113,4 +113,6 @@ int main()
         assert(in.fail());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
index eb272c29b..b30fd5afa 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream out;
@@ -87,4 +87,6 @@ int main()
         assert(L"   " + s == out.str());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
index 944bd4553..f644f2870 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
@@ -33,7 +33,7 @@ test(S s1, S s2)
     assert(s2 == s1_);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -75,4 +75,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
index a00eb17be..3f6ce447c 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
@@ -53,7 +53,7 @@ struct some_alloc2
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -81,4 +81,6 @@ int main()
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
index 527d59d68..bf2cc8413 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
@@ -23,7 +23,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x)
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
index b1e6fa73d..76e0abe23 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
@@ -23,7 +23,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x)
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
index 9825c1b38..30aeb501a 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
@@ -24,7 +24,7 @@ test(const S& lhs, const S& rhs, bool x)
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
index 7108d819e..5b01455e7 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
@@ -22,7 +22,7 @@ test(const S& lhs, SV rhs, bool x)
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
index 8f3906bf1..2d6957e34 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
@@ -22,7 +22,7 @@ test(SV lhs, const S& rhs, bool x)
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
index c24d80768..9ab3c0611 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
@@ -35,7 +35,7 @@ void test1(typename S::value_type lhs, S&& rhs, const S& x) {
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0('a', S(""), S("a"));
@@ -66,4 +66,6 @@ int main() {
     test1('a', S("12345678901234567890"), S("a12345678901234567890"));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
index 654eca290..cf13fbb51 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
@@ -35,7 +35,7 @@ void test1(const typename S::value_type* lhs, S&& rhs, const S& x) {
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0("", S(""), S(""));
@@ -127,4 +127,6 @@ int main() {
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
index 5196aba1a..32411144d 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
@@ -35,7 +35,7 @@ void test1(S&& lhs, typename S::value_type rhs, const S& x) {
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0(S(""), '1', S("1"));
@@ -66,4 +66,6 @@ int main() {
     test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
index ef8b80010..4fec84829 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
@@ -35,7 +35,7 @@ void test1(S&& lhs, const typename S::value_type* rhs, const S& x) {
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0(S(""), "", S(""));
@@ -126,4 +126,6 @@ int main() {
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
index 2bc38c71a..00aaf5cc0 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
@@ -58,7 +58,7 @@ void test3(S&& lhs, S&& rhs, const S& x) {
 
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0(S(""), S(""), S(""));
@@ -245,4 +245,6 @@ int main() {
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
index 11ad5f151..5db04b3a8 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
@@ -23,7 +23,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x)
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
index f020c2234..aa79e17d1 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
@@ -23,7 +23,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x)
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
index 39ec5cc06..357a91fd9 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
@@ -24,7 +24,7 @@ test(const S& lhs, const S& rhs, bool x)
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
index f4791e3b5..06c16d070 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
@@ -22,7 +22,7 @@ test(const S& lhs, SV rhs, bool x)
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
index fdf89a2c9..7ebdc0934 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
@@ -22,7 +22,7 @@ test(SV lhs, const S& rhs, bool x)
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
index dd27087b6..db28cd4d1 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
@@ -23,7 +23,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x)
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
index 4109eab33..56521e916 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
@@ -23,7 +23,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x)
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
index 3514ffc11..0cfafb809 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
@@ -24,7 +24,7 @@ test(const S& lhs, const S& rhs, bool x)
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
index 8ad82bf01..692fbd4fe 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
@@ -22,7 +22,7 @@ test(const S& lhs, SV rhs, bool x)
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
index af98fa153..f6a2fa555 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
@@ -22,7 +22,7 @@ test(SV lhs, const S& rhs, bool x)
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
index 0d7e5acea..e868531a6 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
@@ -23,7 +23,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x)
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
index 93b9d2a87..8aad50782 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
@@ -23,7 +23,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x)
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
index 06f232059..f0ab16cbb 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
@@ -24,7 +24,7 @@ test(const S& lhs, const S& rhs, bool x)
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
index 27c2b35d3..c7eb3e3e4 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
@@ -22,7 +22,7 @@ test(const S& lhs, SV rhs, bool x)
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
index ff4a35b39..b49c1348a 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
@@ -22,7 +22,7 @@ test(SV lhs, const S& rhs, bool x)
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
index 0c3943d7d..1609c4d87 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
@@ -23,7 +23,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x)
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
index d91c3b1ae..079344bb8 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
@@ -23,7 +23,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x)
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
index 0b05b6c35..586faa40f 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
@@ -24,7 +24,7 @@ test(const S& lhs, const S& rhs, bool x)
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
index eec351c24..79393def5 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
@@ -22,7 +22,7 @@ test(const S& lhs, SV rhs, bool x)
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
index 9b2b7ddd9..7e8b139c3 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
@@ -22,7 +22,7 @@ test(SV lhs, const S& rhs, bool x)
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
index 5354e6b75..cae9233df 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
@@ -23,7 +23,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x)
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
index 5fe8948dd..07f9b3551 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
@@ -23,7 +23,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x)
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
index 1261f5185..8d40f2f0a 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
@@ -24,7 +24,7 @@ test(const S& lhs, const S& rhs, bool x)
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
index bdaa49a63..3df9e39cc 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
@@ -22,7 +22,7 @@ test(const S& lhs, SV rhs, bool x)
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
index 64d286cd8..cb7b1a4c4 100644
--- a/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
@@ -22,7 +22,7 @@ test(SV lhs, const S& rhs, bool x)
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@ int main()
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp b/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
index 7c713e4b0..2677230c2 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
@@ -30,7 +30,7 @@ test(const S& s)
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -48,4 +48,6 @@ int main()
     test(S("abcdefghijklmnopqrst"));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
index 9c643a172..6aa07302a 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
@@ -47,7 +47,7 @@ test_nonconst(S& s)
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -74,4 +74,6 @@ int main()
     S s4("abcdefghijklmnopqrst"); test_nonconst(s4);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp b/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
index 6261ad55f..7edf5a88d 100644
--- a/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
@@ -23,7 +23,7 @@ test(const S& s, const typename S::allocator_type& a)
     assert(s.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -43,4 +43,6 @@ int main()
     test(S("abcdefghijklmnopqrst", A()), A());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
index 6219d6bab..0af8ce02f 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
@@ -31,7 +31,7 @@ test(const S& s, const typename S::value_type* str, int x)
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -73,4 +73,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
index ad781f23c..abab9879a 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
@@ -5840,7 +5840,7 @@ void test55()
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 5, -5);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -5989,4 +5989,6 @@ int main()
 //  calls compare(size, size, string(arr), 0, npos)
     assert(s.compare(0, 4, arr, 0, std::string::npos) == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
index aa44e16a9..4e77fc09c 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -361,7 +361,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -377,4 +377,6 @@ int main()
     test2<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
index f9c0244ec..75efbadcc 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -1294,7 +1294,7 @@ void test11()
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 20, 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1328,4 +1328,6 @@ int main()
     test11<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
index 06b5e5310..55fd82371 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -360,7 +360,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@ int main()
     assert(s.compare(0, 1, {"abc", 1}) < 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
index 6a231a867..05ba6ac82 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -5836,7 +5836,7 @@ void test55()
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 5, -5);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -5958,4 +5958,6 @@ int main()
     test55<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
index 00245e834..94c73ab31 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -361,7 +361,7 @@ void test2()
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -379,4 +379,6 @@ int main()
     test2<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
index 7c3bdb159..279ae3075 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
@@ -32,7 +32,7 @@ test(const S& s, const S& str, int x)
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -81,4 +81,6 @@ int main()
     assert(s.compare({"abc", 1}) < 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
index 3e123ad7a..2abc7fc1a 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
@@ -31,7 +31,7 @@ test(const S& s, SV sv, int x)
     assert(sign(s.compare(sv)) == sign(x));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -75,4 +75,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
index 2c4994670..7bada8446 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
@@ -34,7 +34,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -98,4 +98,6 @@ int main()
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
index cb6fc1e97..bd20ea1bb 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@ int main()
     test1<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
index 708a04352..46c5511d9 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@ int main()
     test3<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
index 1ea41354f..7f12ab1ba 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@ int main()
     assert(s.find_first_not_of({"abc", 1}) == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
index 3cb3e7420..54ce737ec 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@ int main()
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
index cf8548744..da630f07e 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
@@ -34,7 +34,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@ int main()
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
index 4c435537c..2162ea14c 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@ int main()
     test1<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
index c8b62b1f4..e0bb0f2fb 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@ int main()
     test3<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
index fc79c89d1..1ae2123c3 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@ int main()
     assert(s.find_first_of({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
index ae29e4748..8cd272408 100644
--- a/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@ int main()
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
index 6276c4910..fd77eb89d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
@@ -34,7 +34,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@ int main()
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
index 5cc9c0bf4..1234ccb4d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@ int main()
     test1<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
index 76834c2e8..4c07f4d61 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@ int main()
     test3<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
index 254e639dc..8232612c1 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@ int main()
     assert(s.find_last_not_of({"abc", 1}) == s.size() - 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
index 421ec966d..da5054b7d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@ int main()
 //     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
index 2c5359e5e..4292b1eb8 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
@@ -34,7 +34,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@ int main()
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
index 6a320788d..0b86a10c5 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@ int main()
     test1<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
index 46d61a44a..9c5f670a9 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@ int main()
     test3<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
index c5f1a3a7d..f3ddb468d 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@ int main()
     assert(s.find_last_of({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
index f98d66eec..ccf181faa 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@ int main()
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
index c346a0196..5700d0957 100644
--- a/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
@@ -34,7 +34,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(0 <= x && x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@ int main()
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
index a6136d3f8..6e7ae3d41 100644
--- a/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
@@ -146,7 +146,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -160,4 +160,6 @@ int main()
     test1<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
index 176ffbb56..fad750717 100644
--- a/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@ void test3()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@ int main()
     test3<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
index 482648ab3..e8a91dd1f 100644
--- a/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@ int main()
     assert(s.find({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
index d84a41e4c..c1e78af10 100644
--- a/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
@@ -139,7 +139,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@ int main()
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
index 9a30a63d1..46ced3123 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
@@ -34,7 +34,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@ int main()
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
index 57a4d06bd..715b5e578 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
@@ -147,7 +147,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@ int main()
     test1<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
index 786affd27..e96700952 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@ void test3()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@ int main()
     test3<S>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
index c83acbf4d..74cfb02ee 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@ int main()
     assert(s.rfind({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
index 3657e028c..ea4f9c205 100644
--- a/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
@@ -139,7 +139,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@ int main()
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp b/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
index 767dc5063..27af66e06 100644
--- a/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
@@ -47,7 +47,7 @@ test(const S& s, typename S::size_type pos, typename S::size_type n)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -173,4 +173,6 @@ int main()
     test(S("dplqartnfgejichmoskb"), 21, 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.require/contiguous.pass.cpp b/test/std/strings/basic.string/string.require/contiguous.pass.cpp
index fb2e3e6ce..be090c90e 100644
--- a/test/std/strings/basic.string/string.require/contiguous.pass.cpp
+++ b/test/std/strings/basic.string/string.require/contiguous.pass.cpp
@@ -24,7 +24,7 @@ void test_contiguous ( const C &c )
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -49,4 +49,6 @@ int main()
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
index bc9fb26a5..8eae5f7c8 100644
--- a/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -30,4 +30,6 @@ int main()
     assert ( s2.starts_with('a'));
     assert (!s2.starts_with('x'));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
index ff46fc33d..412ed574c 100644
--- a/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -58,4 +58,6 @@ int main()
     assert (!sNot.starts_with("abcde"));
     assert ( sNot.starts_with("def"));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
index acb90a0c8..c951b4c73 100644
--- a/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -68,4 +68,6 @@ int main()
     assert (!sNot.starts_with(sv5));
     assert ( sNot.starts_with(svNot));
     }
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/traits_mismatch.fail.cpp b/test/std/strings/basic.string/traits_mismatch.fail.cpp
index 7e57ae1a7..47524d2c3 100644
--- a/test/std/strings/basic.string/traits_mismatch.fail.cpp
+++ b/test/std/strings/basic.string/traits_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::basic_string<char, std::char_traits<wchar_t>> s;
+
+  return 0;
 }
diff --git a/test/std/strings/basic.string/types.pass.cpp b/test/std/strings/basic.string/types.pass.cpp
index 0d074fe05..5aa2c7cf8 100644
--- a/test/std/strings/basic.string/types.pass.cpp
+++ b/test/std/strings/basic.string/types.pass.cpp
@@ -70,7 +70,7 @@ test()
     static_assert(S::npos == -1, "");
 }
 
-int main()
+int main(int, char**)
 {
     test<test_traits<char>, test_allocator<char> >();
     test<std::char_traits<wchar_t>, std::allocator<wchar_t> >();
@@ -81,4 +81,6 @@ int main()
 #if TEST_STD_VER >= 11
     test<std::char_traits<char>, min_allocator<char> >();
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/c.strings/cctype.pass.cpp b/test/std/strings/c.strings/cctype.pass.cpp
index feb5c29d2..c26c1e6a2 100644
--- a/test/std/strings/c.strings/cctype.pass.cpp
+++ b/test/std/strings/c.strings/cctype.pass.cpp
@@ -70,7 +70,7 @@
 #error toupper defined
 #endif
 
-int main()
+int main(int, char**)
 {
 
     ASSERT_SAME_TYPE(int, decltype(std::isalnum(0)));
@@ -102,4 +102,6 @@ int main()
     assert( std::isxdigit('a'));
     assert( std::tolower('A') == 'a');
     assert( std::toupper('a') == 'A');
+
+  return 0;
 }
diff --git a/test/std/strings/c.strings/cstring.pass.cpp b/test/std/strings/c.strings/cstring.pass.cpp
index c61f5c4ff..c8ee2789d 100644
--- a/test/std/strings/c.strings/cstring.pass.cpp
+++ b/test/std/strings/c.strings/cstring.pass.cpp
@@ -17,7 +17,7 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::size_t s = 0;
     void* vp = 0;
@@ -60,4 +60,6 @@ int main()
     ASSERT_SAME_TYPE(const char*, decltype(std::strrchr(cpc, 0)));
     ASSERT_SAME_TYPE(const char*, decltype(std::strstr(cpc, cpc)));
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/c.strings/cuchar.pass.cpp b/test/std/strings/c.strings/cuchar.pass.cpp
index 989ca6b04..4271503d4 100644
--- a/test/std/strings/c.strings/cuchar.pass.cpp
+++ b/test/std/strings/c.strings/cuchar.pass.cpp
@@ -14,6 +14,8 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/c.strings/cwchar.pass.cpp b/test/std/strings/c.strings/cwchar.pass.cpp
index c7558859e..667910bc1 100644
--- a/test/std/strings/c.strings/cwchar.pass.cpp
+++ b/test/std/strings/c.strings/cwchar.pass.cpp
@@ -31,7 +31,7 @@
 #error WEOF not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::mbstate_t mb = {};
     std::size_t s = 0;
@@ -128,4 +128,6 @@ int main()
     ASSERT_SAME_TYPE(int,                decltype(std::vwprintf(L"", va)));
     ASSERT_SAME_TYPE(int,                decltype(std::wprintf(L"")));
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/c.strings/cwctype.pass.cpp b/test/std/strings/c.strings/cwctype.pass.cpp
index a7d9560d7..3bcda1a47 100644
--- a/test/std/strings/c.strings/cwctype.pass.cpp
+++ b/test/std/strings/c.strings/cwctype.pass.cpp
@@ -90,7 +90,7 @@
 #error wctrans defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::wint_t w = 0;
     ASSERT_SAME_TYPE(int, decltype(std::iswalnum(w)));
@@ -113,4 +113,6 @@ int main()
     ASSERT_SAME_TYPE(std::wint_t,    decltype(std::towupper(w)));
     ASSERT_SAME_TYPE(std::wint_t,    decltype(std::towctrans(w, std::wctrans_t())));
     ASSERT_SAME_TYPE(std::wctrans_t, decltype(std::wctrans("")));
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp b/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
index 8f80a53ed..c60e6db9f 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     char c = '\0';
     std::char_traits<char>::assign(c, 'a');
@@ -36,4 +36,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
index 74e0f9076..e2cbe3d5d 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     char s2[3] = {0};
     assert(std::char_traits<char>::assign(s2, 3, char(5)) == s2);
@@ -23,4 +23,6 @@ int main()
     assert(s2[1] == char(5));
     assert(s2[2] == char(5));
     assert(std::char_traits<char>::assign(NULL, 0, char(5)) == NULL);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
index 637095127..4926b6296 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::compare("", "", 0) == 0);
     assert(std::char_traits<char>::compare(NULL, NULL, 0) == 0);
@@ -53,4 +53,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
index bd12bfd21..3a8e3bda6 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     char s1[] = {1, 2, 3};
     char s2[3] = {0};
@@ -25,4 +25,6 @@ int main()
     assert(s2[2] == char(3));
     assert(std::char_traits<char>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char>::copy(s1, NULL, 0) == s1);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
index ad99e30b2..0ea0995da 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
@@ -15,7 +15,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::eof() == EOF);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
index 7895baf99..f0cef792d 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
@@ -15,8 +15,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::eq('a', 'a'));
     assert(!std::char_traits<char>::eq('a', 'A'));
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
index ca6808f86..0fbb4389c 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::char_traits<char>::eq_int_type('a', 'a'));
     assert(!std::char_traits<char>::eq_int_type('a', 'A'));
     assert(!std::char_traits<char>::eq_int_type(std::char_traits<char>::eof(), 'A'));
     assert( std::char_traits<char>::eq_int_type(std::char_traits<char>::eof(),
                                                 std::char_traits<char>::eof()));
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
index 242d3a173..974500840 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
@@ -29,7 +29,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     char s1[] = {1, 2, 3};
     assert(std::char_traits<char>::find(s1, 3, char(1)) == s1);
@@ -42,4 +42,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
index f556c952e..8be4e0a70 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 #endif
 
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::length("") == 0);
     assert(std::char_traits<char>::length("a") == 1);
@@ -38,4 +38,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
index 497679636..e62090cf4 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::char_traits<char>::lt('\0', 'A'));
     assert(!std::char_traits<char>::lt('A', '\0'));
@@ -29,4 +29,6 @@ int main()
 
     assert( std::char_traits<char>::lt(' ', 'A'));
     assert( std::char_traits<char>::lt('A', '~'));
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
index c1f885939..ecbb61901 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     char s1[] = {1, 2, 3};
     assert(std::char_traits<char>::move(s1, s1+1, 2) == s1);
@@ -29,4 +29,6 @@ int main()
     assert(s1[2] == char(3));
     assert(std::char_traits<char>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char>::move(s1, NULL, 0) == s1);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
index 01568e5a4..1c37a7c2e 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::not_eof('a') == 'a');
     assert(std::char_traits<char>::not_eof('A') == 'A');
     assert(std::char_traits<char>::not_eof(0) == 0);
     assert(std::char_traits<char>::not_eof(std::char_traits<char>::eof()) !=
            std::char_traits<char>::eof());
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
index fbf8f2f58..d8a957016 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::to_char_type('a') == 'a');
     assert(std::char_traits<char>::to_char_type('A') == 'A');
     assert(std::char_traits<char>::to_char_type(0) == 0);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
index eb8df3b69..dd903f9e6 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::to_int_type('a') == 'a');
     assert(std::char_traits<char>::to_int_type('A') == 'A');
     assert(std::char_traits<char>::to_int_type(0) == 0);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
index 6439c1ea0..30d31ebc9 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
@@ -19,11 +19,13 @@
 #include <string>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::char_traits<char>::char_type, char>::value), "");
     static_assert((std::is_same<std::char_traits<char>::int_type, int>::value), "");
     static_assert((std::is_same<std::char_traits<char>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<char>::pos_type, std::streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char>::state_type, std::mbstate_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
index 77b8687e8..017d0e7ac 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -40,4 +40,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
index c623baa24..8838b81e1 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s2[3] = {0};
@@ -25,4 +25,6 @@ int main()
     assert(s2[2] == char16_t(5));
     assert(std::char_traits<char16_t>::assign(NULL, 0, char16_t(5)) == NULL);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
index 2e3b18aca..d0782c093 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
@@ -28,7 +28,7 @@ constexpr bool test_constexpr()
 #endif
 
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -58,4 +58,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
index 0bf5d47ee..102f15acd 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
@@ -27,4 +27,6 @@ int main()
     assert(std::char_traits<char16_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char16_t>::copy(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
index bb0a4506a..c80b0792a 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
@@ -15,10 +15,12 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     std::char_traits<char16_t>::int_type i = std::char_traits<char16_t>::eof();
     ((void)i); // Prevent unused warning
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
index f4abe84db..1c705109f 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@ int main()
     assert(!std::char_traits<char16_t>::eq(u'a', u'A'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
index 9a24cf13d..bef97d612 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@ int main()
     assert( std::char_traits<char16_t>::eq_int_type(std::char_traits<char16_t>::eof(),
                                                     std::char_traits<char16_t>::eof()));
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
index cd31e5925..2ca7e5343 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
@@ -29,7 +29,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
@@ -44,4 +44,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
index 2a2a35702..f487c410b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -41,4 +41,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
index 4ade9b6f0..a43a9e45c 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@ int main()
     assert( std::char_traits<char16_t>::lt(u'A', u'a'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
index ddf07a022..aa55e0d11 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
@@ -31,4 +31,6 @@ int main()
     assert(std::char_traits<char16_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char16_t>::move(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
index ea6f0ab17..bf26b4cf3 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@ int main()
     assert(std::char_traits<char16_t>::not_eof(std::char_traits<char16_t>::eof()) !=
            std::char_traits<char16_t>::eof());
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
index 9256a5281..738754bf9 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@ int main()
 #endif
     assert(std::char_traits<char16_t>::to_char_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
index 411f5202b..83fff60b8 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@ int main()
 #endif
     assert(std::char_traits<char16_t>::to_int_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
index ae8792c49..41e3fd4d5 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::char_traits<char16_t>::char_type, char16_t>::value), "");
@@ -29,4 +29,6 @@ int main()
     static_assert((std::is_same<std::char_traits<char16_t>::pos_type, std::u16streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::state_type, std::mbstate_t>::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
index 90388aa43..f77d54f79 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -40,4 +40,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
index af69fdcfa..26985481c 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s2[3] = {0};
@@ -25,4 +25,6 @@ int main()
     assert(s2[2] == char32_t(5));
     assert(std::char_traits<char32_t>::assign(NULL, 0, char32_t(5)) == NULL);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
index 5d1cfa842..f2dd01ac9 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -57,4 +57,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
index d9f983b5b..8b2d6ce90 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
@@ -27,4 +27,6 @@ int main()
     assert(std::char_traits<char32_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char32_t>::copy(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
index ac042907a..5c28f47bb 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
@@ -15,10 +15,12 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     std::char_traits<char32_t>::int_type i = std::char_traits<char32_t>::eof();
     ((void)i); // Prevent unused warning
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
index aef7ebb70..516f38bd0 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@ int main()
     assert(!std::char_traits<char32_t>::eq(U'a', U'A'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
index 91b2fb0fb..5d241159f 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@ int main()
     assert( std::char_traits<char32_t>::eq_int_type(std::char_traits<char32_t>::eof(),
                                                     std::char_traits<char32_t>::eof()));
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
index ac1723a65..5a89596de 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
@@ -29,7 +29,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
@@ -44,4 +44,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
index c4c01ddf1..ef2ea3419 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -41,4 +41,6 @@ int main()
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
index d3fe9a451..51c1faf9e 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@ int main()
     assert( std::char_traits<char32_t>::lt(U'A', U'a'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
index 0ac49d0c9..7cda99bd8 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
@@ -31,4 +31,6 @@ int main()
     assert(std::char_traits<char32_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char32_t>::move(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
index dbe1dfe8b..aeba1228e 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@ int main()
     assert(std::char_traits<char32_t>::not_eof(std::char_traits<char32_t>::eof()) !=
            std::char_traits<char32_t>::eof());
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
index 1c16a55b8..75104e7bf 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@ int main()
 #endif
     assert(std::char_traits<char32_t>::to_char_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
index 4ec9a9b63..8299e94da 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@ int main()
 #endif
     assert(std::char_traits<char32_t>::to_int_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
index 65624dd5e..5ec558f54 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::char_traits<char32_t>::char_type, char32_t>::value), "");
@@ -29,4 +29,6 @@ int main()
     static_assert((std::is_same<std::char_traits<char32_t>::pos_type, std::u32streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char32_t>::state_type, std::mbstate_t>::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
index b14662d09..c669ab9c1 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
@@ -25,7 +25,7 @@ constexpr bool test_constexpr()
     return c == u'a';
 }
 
-int main()
+int main(int, char**)
 {
     char8_t c = u8'\0';
     std::char_traits<char8_t>::assign(c, u8'a');
@@ -34,5 +34,7 @@ int main()
     static_assert(test_constexpr(), "");
 }
 #else
-int main () {}
+int main(int, char**) {
+  return 0;
+}
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
index eae7c82ba..f9c176e9b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     char8_t s2[3] = {0};
@@ -26,4 +26,6 @@ int main()
     assert(s2[2] == char8_t(5));
     assert(std::char_traits<char8_t>::assign(NULL, 0, char8_t(5)) == NULL);
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
index 0ac815b9b..063ab5dc5 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char8_t>::compare(u8"", u8"", 0) == 0);
     assert(std::char_traits<char8_t>::compare(NULL, NULL, 0) == 0);
@@ -53,5 +53,7 @@ int main()
     static_assert(test_constexpr(), "" );
 }
 #else
-int main () {}
+int main(int, char**) {
+  return 0;
+}
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
index 2f091029b..7bf949197 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     char8_t s1[] = {1, 2, 3};
@@ -28,4 +28,6 @@ int main()
     assert(std::char_traits<char8_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char8_t>::copy(s1, NULL, 0) == s1);
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
index 9d13d7dd0..e11255688 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     std::char_traits<char8_t>::int_type i = std::char_traits<char8_t>::eof();
     ((void)i); // Prevent unused warning
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
index 4d334110f..6e32c85bb 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
@@ -18,10 +18,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert( std::char_traits<char8_t>::eq(u8'a', u8'a'));
     assert(!std::char_traits<char8_t>::eq(u8'a', u8'A'));
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
index 6cc58eba1..8c5e19717 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert( std::char_traits<char8_t>::eq_int_type(u8'a', u8'a'));
@@ -27,4 +27,6 @@ int main()
     assert( std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(),
                                                     std::char_traits<char8_t>::eof()));
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
index 9d2e62e34..170539e06 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
@@ -28,7 +28,7 @@ constexpr bool test_constexpr()
         && std::char_traits<char8_t>::find(p, 3, u8'4') == nullptr;
 }
 
-int main()
+int main(int, char**)
 {
     char8_t s1[] = {1, 2, 3};
     assert(std::char_traits<char8_t>::find(s1, 3, char8_t(1)) == s1);
@@ -41,5 +41,7 @@ int main()
     static_assert(test_constexpr(), "" );
 }
 #else
-int main () {}
+int main(int, char**) {
+  return 0;
+}
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
index 10f800127..ce2c717cc 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
@@ -25,7 +25,7 @@ constexpr bool test_constexpr()
         && std::char_traits<char8_t>::length(u8"abcd") == 4;
 }
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char8_t>::length(u8"") == 0);
     assert(std::char_traits<char8_t>::length(u8"a") == 1);
@@ -36,5 +36,7 @@ int main()
     static_assert(test_constexpr(), "");
 }
 #else
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
 #endif
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
index 4653007bf..a4fb12512 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
@@ -18,10 +18,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(!std::char_traits<char8_t>::lt(u8'a', u8'a'));
     assert( std::char_traits<char8_t>::lt(u8'A', u8'a'));
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
index 5ca536966..a5e1359dd 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     char8_t s1[] = {1, 2, 3};
@@ -32,4 +32,6 @@ int main()
     assert(std::char_traits<char8_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char8_t>::move(s1, NULL, 0) == s1);
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
index 69e8ddac8..3d1141d72 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(std::char_traits<char8_t>::not_eof(u8'a') == u8'a');
@@ -27,4 +27,6 @@ int main()
     assert(std::char_traits<char8_t>::not_eof(std::char_traits<char8_t>::eof()) !=
            std::char_traits<char8_t>::eof());
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
index 0b021d283..4edc49452 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
@@ -18,11 +18,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(std::char_traits<char8_t>::to_char_type(u8'a') == u8'a');
     assert(std::char_traits<char8_t>::to_char_type(u8'A') == u8'A');
     assert(std::char_traits<char8_t>::to_char_type(0) == 0);
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
index 98974ab86..ab3c9dc79 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
@@ -18,11 +18,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(std::char_traits<char8_t>::to_int_type(u8'a') == u8'a');
     assert(std::char_traits<char8_t>::to_int_type(u8'A') == u8'A');
     assert(std::char_traits<char8_t>::to_int_type(0) == 0);
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
index cfb20faaf..245dcd87d 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     static_assert((std::is_same<std::char_traits<char8_t>::char_type,  char8_t>::value), "");
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<std::char_traits<char8_t>::pos_type,   std::u16streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
index 9b9b0ea49..25e427014 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     wchar_t c = L'\0';
     std::char_traits<wchar_t>::assign(c, L'a');
@@ -36,4 +36,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
index 42df4081d..d4ed43409 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     wchar_t s2[3] = {0};
     assert(std::char_traits<wchar_t>::assign(s2, 3, wchar_t(5)) == s2);
@@ -23,4 +23,6 @@ int main()
     assert(s2[1] == wchar_t(5));
     assert(s2[2] == wchar_t(5));
     assert(std::char_traits<wchar_t>::assign(NULL, 0, wchar_t(5)) == NULL);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
index d6272f393..1c2e11912 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::compare(L"", L"", 0) == 0);
     assert(std::char_traits<wchar_t>::compare(NULL, NULL, 0) == 0);
@@ -53,4 +53,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
index f90688a9a..309c21316 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     wchar_t s1[] = {1, 2, 3};
     wchar_t s2[3] = {0};
@@ -25,4 +25,6 @@ int main()
     assert(s2[2] == wchar_t(3));
     assert(std::char_traits<wchar_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<wchar_t>::copy(s1, NULL, 0) == s1);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
index 9b466a5f0..6190220fe 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
@@ -15,7 +15,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::eof() == WEOF);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
index a89a0002d..701a6502f 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
@@ -15,8 +15,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::eq(L'a', L'a'));
     assert(!std::char_traits<wchar_t>::eq(L'a', L'A'));
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
index e7e8285ca..b218186b4 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::char_traits<wchar_t>::eq_int_type(L'a', L'a'));
     assert(!std::char_traits<wchar_t>::eq_int_type(L'a', L'A'));
     assert(!std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(), L'A'));
     assert( std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(),
                                                    std::char_traits<wchar_t>::eof()));
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
index ed59397cc..78a9ad5c3 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
@@ -29,7 +29,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     wchar_t s1[] = {1, 2, 3};
     assert(std::char_traits<wchar_t>::find(s1, 3, wchar_t(1)) == s1);
@@ -42,4 +42,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
index a9176c8d4..742189205 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::length(L"") == 0);
     assert(std::char_traits<wchar_t>::length(L"a") == 1);
@@ -37,4 +37,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
index f7950b782..9abd9cf59 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
@@ -15,8 +15,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(!std::char_traits<wchar_t>::lt(L'a', L'a'));
     assert( std::char_traits<wchar_t>::lt(L'A', L'a'));
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
index d833bc0b5..341a90233 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     wchar_t s1[] = {1, 2, 3};
     assert(std::char_traits<wchar_t>::move(s1, s1+1, 2) == s1);
@@ -29,4 +29,6 @@ int main()
     assert(s1[2] == wchar_t(3));
     assert(std::char_traits<wchar_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<wchar_t>::move(s1, NULL, 0) == s1);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
index 751903bea..92f08b1d5 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::not_eof(L'a') == L'a');
     assert(std::char_traits<wchar_t>::not_eof(L'A') == L'A');
     assert(std::char_traits<wchar_t>::not_eof(0) == 0);
     assert(std::char_traits<wchar_t>::not_eof(std::char_traits<wchar_t>::eof()) !=
            std::char_traits<wchar_t>::eof());
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
index 7654c3287..f479bec9d 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::to_char_type(L'a') == L'a');
     assert(std::char_traits<wchar_t>::to_char_type(L'A') == L'A');
     assert(std::char_traits<wchar_t>::to_char_type(0) == 0);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
index a003bdc11..11fe2419b 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::to_int_type(L'a') == L'a');
     assert(std::char_traits<wchar_t>::to_int_type(L'A') == L'A');
     assert(std::char_traits<wchar_t>::to_int_type(0) == 0);
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
index c367be47e..9781d55e3 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
@@ -19,11 +19,13 @@
 #include <string>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::int_type, std::wint_t>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::pos_type, std::wstreampos>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::state_type, std::mbstate_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp b/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/char.traits/nothing_to_do.pass.cpp b/test/std/strings/char.traits/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/strings/char.traits/nothing_to_do.pass.cpp
+++ b/test/std/strings/char.traits/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/strings/string.classes/typedefs.pass.cpp b/test/std/strings/string.classes/typedefs.pass.cpp
index 14fe38877..cbc028391 100644
--- a/test/std/strings/string.classes/typedefs.pass.cpp
+++ b/test/std/strings/string.classes/typedefs.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::string, std::basic_string<char> >::value), "");
     static_assert((std::is_same<std::wstring, std::basic_string<wchar_t> >::value), "");
@@ -33,4 +33,6 @@ int main()
     static_assert((std::is_same<std::u16string, std::basic_string<char16_t> >::value), "");
     static_assert((std::is_same<std::u32string, std::basic_string<char32_t> >::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stod.pass.cpp b/test/std/strings/string.conversions/stod.pass.cpp
index 9909497e6..d13b695f2 100644
--- a/test/std/strings/string.conversions/stod.pass.cpp
+++ b/test/std/strings/string.conversions/stod.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stod("0") == 0);
     assert(std::stod(L"0") == 0);
@@ -185,4 +185,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stof.pass.cpp b/test/std/strings/string.conversions/stof.pass.cpp
index 8e7f4b4ec..2c8e4c9b9 100644
--- a/test/std/strings/string.conversions/stof.pass.cpp
+++ b/test/std/strings/string.conversions/stof.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stof("0") == 0);
     assert(std::stof(L"0") == 0);
@@ -186,4 +186,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stoi.pass.cpp b/test/std/strings/string.conversions/stoi.pass.cpp
index 36998336c..b3e416331 100644
--- a/test/std/strings/string.conversions/stoi.pass.cpp
+++ b/test/std/strings/string.conversions/stoi.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoi("0") == 0);
     assert(std::stoi(L"0") == 0);
@@ -109,4 +109,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stol.pass.cpp b/test/std/strings/string.conversions/stol.pass.cpp
index 8e18a0088..ef0cbb4ed 100644
--- a/test/std/strings/string.conversions/stol.pass.cpp
+++ b/test/std/strings/string.conversions/stol.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stol("0") == 0);
     assert(std::stol(L"0") == 0);
@@ -113,4 +113,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stold.pass.cpp b/test/std/strings/string.conversions/stold.pass.cpp
index 4677bd7d2..5b21fd0e3 100644
--- a/test/std/strings/string.conversions/stold.pass.cpp
+++ b/test/std/strings/string.conversions/stold.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stold("0") == 0);
     assert(std::stold(L"0") == 0);
@@ -188,4 +188,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stoll.pass.cpp b/test/std/strings/string.conversions/stoll.pass.cpp
index f8a5a6b0e..73d5e8201 100644
--- a/test/std/strings/string.conversions/stoll.pass.cpp
+++ b/test/std/strings/string.conversions/stoll.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoll("0") == 0);
     assert(std::stoll(L"0") == 0);
@@ -112,4 +112,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stoul.pass.cpp b/test/std/strings/string.conversions/stoul.pass.cpp
index e60a6a071..6ef861396 100644
--- a/test/std/strings/string.conversions/stoul.pass.cpp
+++ b/test/std/strings/string.conversions/stoul.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoul("0") == 0);
     assert(std::stoul(L"0") == 0);
@@ -111,4 +111,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/stoull.pass.cpp b/test/std/strings/string.conversions/stoull.pass.cpp
index 32369664d..3e21c683a 100644
--- a/test/std/strings/string.conversions/stoull.pass.cpp
+++ b/test/std/strings/string.conversions/stoull.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoull("0") == 0);
     assert(std::stoull(L"0") == 0);
@@ -112,4 +112,6 @@ int main()
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/to_string.pass.cpp b/test/std/strings/string.conversions/to_string.pass.cpp
index 864425134..23729cd4f 100644
--- a/test/std/strings/string.conversions/to_string.pass.cpp
+++ b/test/std/strings/string.conversions/to_string.pass.cpp
@@ -112,7 +112,7 @@ test_float()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_signed<int>();
     test_signed<long>();
@@ -123,4 +123,6 @@ int main()
     test_float<float>();
     test_float<double>();
     test_float<long double>();
+
+  return 0;
 }
diff --git a/test/std/strings/string.conversions/to_wstring.pass.cpp b/test/std/strings/string.conversions/to_wstring.pass.cpp
index 82c3f617b..02a262a0f 100644
--- a/test/std/strings/string.conversions/to_wstring.pass.cpp
+++ b/test/std/strings/string.conversions/to_wstring.pass.cpp
@@ -112,7 +112,7 @@ test_float()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_signed<int>();
     test_signed<long>();
@@ -123,4 +123,6 @@ int main()
     test_float<float>();
     test_float<double>();
     test_float<long double>();
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/char.bad.fail.cpp b/test/std/strings/string.view/char.bad.fail.cpp
index 3d04cd085..522466613 100644
--- a/test/std/strings/string.view/char.bad.fail.cpp
+++ b/test/std/strings/string.view/char.bad.fail.cpp
@@ -26,7 +26,7 @@ private:
     int two;
 };
 
-int main()
+int main(int, char**)
 {
     {
 //  array
@@ -49,4 +49,6 @@ int main()
     std::basic_string_view<NotStandardLayout, test_traits<NotStandardLayout> > sv;
 //  expected-error-re@string_view:* {{static_assert failed{{.*}} "Character type of basic_string_view must be standard-layout"}}
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.access/at.pass.cpp b/test/std/strings/string.view/string.view.access/at.pass.cpp
index b4b2667bb..3d741c33f 100644
--- a/test/std/strings/string.view/string.view.access/at.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/at.pass.cpp
@@ -36,7 +36,7 @@ void test ( const CharT *s, size_t len ) {
 #endif
 }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
@@ -59,4 +59,6 @@ int main () {
     static_assert ( sv.at(1) == 'B', "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.access/back.pass.cpp b/test/std/strings/string.view/string.view.access/back.pass.cpp
index 8c8fd420d..4505f1cf9 100644
--- a/test/std/strings/string.view/string.view.access/back.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/back.pass.cpp
@@ -24,7 +24,7 @@ bool test ( const CharT *s, size_t len ) {
     return &sv.back() == s + len - 1;
     }
 
-int main () {
+int main(int, char**) {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
 
@@ -46,4 +46,6 @@ int main () {
     static_assert ( sv.back()  == 'B', "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.access/data.pass.cpp b/test/std/strings/string.view/string.view.access/data.pass.cpp
index 85e02ceb0..9ab83dfb2 100644
--- a/test/std/strings/string.view/string.view.access/data.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/data.pass.cpp
@@ -27,7 +27,7 @@ void test ( const CharT *s, size_t len ) {
 #endif
     }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
@@ -50,4 +50,6 @@ int main () {
     static_assert( sv.data() == s, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.access/front.pass.cpp b/test/std/strings/string.view/string.view.access/front.pass.cpp
index 6e73202d6..554ed1bab 100644
--- a/test/std/strings/string.view/string.view.access/front.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/front.pass.cpp
@@ -24,7 +24,7 @@ bool test ( const CharT *s, size_t len ) {
     return &sv.front() == s;
     }
 
-int main () {
+int main(int, char**) {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
 
@@ -46,4 +46,6 @@ int main () {
     static_assert ( sv.front()  == 'A', "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.access/index.pass.cpp b/test/std/strings/string.view/string.view.access/index.pass.cpp
index 87598dffe..33992de7c 100644
--- a/test/std/strings/string.view/string.view.access/index.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/index.pass.cpp
@@ -26,7 +26,7 @@ void test ( const CharT *s, size_t len ) {
         }
     }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
@@ -49,4 +49,6 @@ int main () {
     static_assert ( sv[1]  == 'B', "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp b/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
index 93cc76283..025d905a3 100644
--- a/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
+++ b/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
@@ -62,7 +62,7 @@ void test2 ( const CharT *s, size_t len ) {
     }
 }
 
-int main () {
+int main(int, char**) {
     test1<std::string_view> ();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test1<std::u8string_view> ();
@@ -99,4 +99,6 @@ int main () {
     test2 ( U"a", 1 );
     test2 ( U"", 0 );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.capacity/empty.fail.cpp b/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
index 74bd41302..1dd1dcf7c 100644
--- a/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
+++ b/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::string_view c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
index bb6c34316..e771bd328 100644
--- a/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@ test(S lhs, const typename S::value_type* rhs, bool x)
     assert((rhs == lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -65,4 +65,6 @@ int main()
     static_assert (!("abcde0" == sv2), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
index bb142b0b3..d27d4c445 100644
--- a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
@@ -25,7 +25,7 @@ test(const std::string &lhs, S rhs, bool x)
     assert((rhs == lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,5 +46,7 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
+
+  return 0;
 }
 
diff --git a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
index d7b113c12..259711e3c 100644
--- a/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@ test(S lhs, S rhs, bool x)
     assert((rhs == lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -58,4 +58,6 @@ int main()
     static_assert (!(sv1 == sv3), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
index 4f32425dc..5fa57eb39 100644
--- a/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
     assert((rhs >= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@ int main()
     static_assert (  "abcde0" >= sv2, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
index 9cbe389cd..dddaa390e 100644
--- a/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
@@ -25,7 +25,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
     assert((rhs >= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true, false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true, true);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
index 81fee1f39..d35bea575 100644
--- a/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@ test(const S& lhs, const S& rhs, bool x, bool y)
     assert((rhs >= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@ int main()
     static_assert (  sv2 >= sv1,  "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
index c295645a9..80dcc7b49 100644
--- a/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
     assert((rhs > lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@ int main()
     static_assert (  "abcde0" > sv2, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
index b07b6a7ac..84c9478bf 100644
--- a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
@@ -25,7 +25,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
     assert((rhs > lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true, false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false, false);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
index 984f2c6a3..ec31d5c2c 100644
--- a/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@ test(const S& lhs, const S& rhs, bool x, bool y)
     assert((rhs > lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@ int main()
     static_assert (  sv2 > sv1, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
index 81d0d167a..4f582239a 100644
--- a/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
     assert((rhs <= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@ int main()
     static_assert (!("abcde0" <= sv2), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
index 3cdb0215e..80e80757b 100644
--- a/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
@@ -25,7 +25,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
     assert((rhs <= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false, true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true, true);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
index 3ec0222f6..b1c186124 100644
--- a/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@ test(const S& lhs, const S& rhs, bool x, bool y)
     assert((rhs <= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@ int main()
     static_assert (!(sv2 <= sv1), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
index f8093c86a..14bba2abf 100644
--- a/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@ test(const typename S::value_type* lhs, const S& rhs, bool x, bool y)
     assert((rhs < lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@ int main()
     static_assert (!("abcde0" < sv2), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
index e7341f17d..f611bac7a 100644
--- a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
@@ -25,7 +25,7 @@ test(const S& lhs, const typename S::value_type* rhs, bool x, bool y)
     assert((rhs < lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@ int main()
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false, true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false, false);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
index a7e51f9af..f44e37361 100644
--- a/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@ test(const S& lhs, const S& rhs, bool x, bool y)
     assert((rhs < lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@ int main()
     static_assert (!(sv2 < sv1), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp b/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
index 1531626a8..6b8add831 100644
--- a/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@ test(S lhs, const typename S::value_type* rhs, bool x)
     assert((rhs != lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -66,4 +66,6 @@ int main()
     static_assert (  "abcde0" != sv2, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp b/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
index 8e5539a80..613eaf7b3 100644
--- a/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
@@ -25,7 +25,7 @@ test(const std::string &lhs, S rhs, bool x)
     assert((rhs != lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@ int main()
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp b/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
index 0e01e94db..90d153335 100644
--- a/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@ test(S lhs, S rhs, bool x)
     assert((rhs != lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -58,4 +58,6 @@ int main()
     static_assert (   sv1 != sv3,  "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/assign.pass.cpp b/test/std/strings/string.view/string.view.cons/assign.pass.cpp
index 8247c53c7..b2bf8ed71 100644
--- a/test/std/strings/string.view/string.view.cons/assign.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/assign.pass.cpp
@@ -29,7 +29,7 @@ bool test (T sv0)
     return sv0.size() == sv1.size() && sv0.data() == sv1.data();
     }
 
-int main () {
+int main(int, char**) {
 
     assert( test<std::string_view>    (  "1234"));
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -54,4 +54,6 @@ int main () {
 #endif
     static_assert( test<std::wstring_view>   ({ L"abc", 3}), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/default.pass.cpp b/test/std/strings/string.view/string.view.cons/default.pass.cpp
index fe1fa9740..07a453b23 100644
--- a/test/std/strings/string.view/string.view.cons/default.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/default.pass.cpp
@@ -35,7 +35,7 @@ void test () {
     }
 }
 
-int main () {
+int main(int, char**) {
     test<std::string_view> ();
     test<std::u16string_view> ();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -44,4 +44,6 @@ int main () {
     test<std::u32string_view> ();
     test<std::wstring_view> ();
 
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp b/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
index 7430f4ad6..bcd83da74 100644
--- a/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
@@ -39,7 +39,7 @@ void test ( const CharT *s ) {
     }
 
 
-int main () {
+int main(int, char**) {
 
     test ( "QBCDE" );
     test ( "A" );
@@ -65,4 +65,6 @@ int main () {
     static_assert ( sv1.size() == 5, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp b/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
index 8ad0449aa..92ae675a3 100644
--- a/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
@@ -31,7 +31,7 @@ void test ( const CharT *s, size_t sz ) {
     }
 }
 
-int main () {
+int main(int, char**) {
 
     test ( "QBCDE", 5 );
     test ( "QBCDE", 2 );
@@ -82,4 +82,6 @@ int main () {
     }
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/from_string.pass.cpp b/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
index 5e4a2d319..2043d662a 100644
--- a/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
@@ -31,7 +31,7 @@ void test ( const std::basic_string<CharT, Traits> &str ) {
     assert ( sv1.data() == str.data());
 }
 
-int main () {
+int main(int, char**) {
 
     test ( std::string("QBCDE") );
     test ( std::string("") );
@@ -61,4 +61,6 @@ int main () {
     test ( std::basic_string<char, dummy_char_traits>("") );
     test ( std::basic_string<char, dummy_char_traits>() );
 
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
index 343600625..3c464d7fe 100644
--- a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
@@ -18,7 +18,7 @@
 
 struct dummy_char_traits : public std::char_traits<char> {};
 
-int main () {
+int main(int, char**) {
     using string_view = std::basic_string_view<char>;
     using string      = std::              basic_string     <char, dummy_char_traits>;
 
@@ -28,4 +28,6 @@ int main () {
     assert ( sv1.size() == s.size());
     assert ( sv1.data() == s.data());
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp b/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
index 2a0544def..482d22001 100644
--- a/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
@@ -18,7 +18,7 @@
 
 struct dummy_char_traits : public std::char_traits<char> {};
 
-int main () {
+int main(int, char**) {
     using string_view = std::basic_string_view<char, dummy_char_traits>;
     using string      = std::              basic_string     <char>;
 
@@ -28,4 +28,6 @@ int main () {
     assert ( sv1.size() == s.size());
     assert ( sv1.data() == s.data());
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp b/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
index 3f1f562a4..b95dca63d 100644
--- a/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
@@ -26,7 +26,7 @@
 // (2)  basic_string_view(const basic_string_view&)
 // (3)  basic_string_view(const CharT*, size_type)
 // (4)  basic_string_view(const CharT*)
-int main()
+int main(int, char**)
 {
   { // Testing (1)
     // Nothing TODO. Cannot deduce without any arguments.
@@ -61,4 +61,6 @@ int main()
     ASSERT_SAME_TYPE(decltype(w), std::wstring_view);
     assert(w == L"abcdef");
   }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
index 8898d11af..82173a93a 100644
--- a/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
@@ -35,7 +35,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(0 <= x && x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -81,4 +81,6 @@ int main()
     static_assert (sv2.find( 'c', 4 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
index aae4048ac..4566adabf 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
@@ -35,7 +35,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -81,4 +81,6 @@ int main()
     static_assert (sv2.find_first_not_of( 'q', 5 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
index 0020e60b8..17c3c5293 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@ int main()
     static_assert (sv2.find_first_not_of( "lecar", 0) == 1, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
index 52f069676..707a7a964 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@ int main()
     static_assert (sv2.find_first_not_of( "lecar", 0, 5) == 1, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
index 9378c6a0f..37445b578 100644
--- a/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
index 6be6ddcd9..d4916bec3 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
@@ -35,7 +35,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -79,4 +79,6 @@ int main()
     static_assert (sv2.find_first_of( 'e', 5 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
index bc3ea554b..7e43109af 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@ int main()
     static_assert (sv2.find_first_of( "lecar", 0) == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
index cd978436e..165fb2362 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@ int main()
     static_assert (sv2.find_first_of( "lecar", 0, 5) == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
index 545f4e515..c705f0266 100644
--- a/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
index 8d80557d4..0b6e6cfb0 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
@@ -35,7 +35,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -79,4 +79,6 @@ int main()
     static_assert (sv2.find_last_not_of( 'e', 5 ) == 3, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
index f7daf3fa3..fe17b779d 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@ int main()
     static_assert (sv2.find_last_not_of( "lecar", 5) == 3, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
index 8fd255395..11a5c27e8 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@ int main()
     static_assert (sv2.find_last_not_of( "lecar", 5, 0) == 4, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
index 06a31a1d6..e90e38c0d 100644
--- a/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
index 147e191b2..fdcf31736 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
@@ -35,7 +35,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -79,4 +79,6 @@ int main()
     static_assert (sv2.find_last_of( 'e', 5 ) == 4, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
index 5a1271831..640f48375 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@ int main()
     static_assert (sv2.find_last_of( "lecar", 5) == 4, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
index 984029826..e82c935b5 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@ void test3()
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@ int main()
     static_assert (sv2.find_last_of( "lecar", 5, 5) == 4, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
index 84b5a96df..02c1184ee 100644
--- a/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@ void test1()
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
index 2be32a46a..3f4fee54e 100644
--- a/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
@@ -147,7 +147,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -168,4 +168,6 @@ int main()
     static_assert (sv2.find( "abcde", 1) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
index 0f7d295a4..74caa6fea 100644
--- a/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@ void test3()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -390,4 +390,6 @@ int main()
     static_assert (sv2.find( "abcde", 0, 1 ) == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
index 0a5cec54e..ed3b7c11c 100644
--- a/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -161,4 +161,6 @@ int main()
     static_assert (sv2.find(sv2, 1 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
index 62f50ed87..959bb05f8 100644
--- a/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
@@ -34,7 +34,7 @@ test(const S& s, typename S::value_type c, typename S::size_type x)
         assert(x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -80,4 +80,6 @@ int main()
     static_assert (sv2.rfind( 'b', 4 ) == 1, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
index 0ff2be51f..6010083ab 100644
--- a/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
@@ -147,7 +147,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -168,4 +168,6 @@ int main()
     static_assert (sv2.rfind( "abcde", 1) == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
index 18fd8437d..c3ca97e7f 100644
--- a/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@ void test3()
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@ int main()
     static_assert (sv2.rfind( "abcde", 0, 1 ) == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp b/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
index dfc4a8361..c4ceef331 100644
--- a/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
@@ -140,7 +140,7 @@ void test1()
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -161,4 +161,6 @@ int main()
     static_assert (sv2.rfind(sv2, 1) == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp b/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
index 21dcbdf30..d52f16303 100644
--- a/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
+++ b/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::string_view>();
@@ -30,4 +30,6 @@ int main() {
     test_hash_enabled_for_type<std::u32string_view>();
 #endif
   }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.hash/string_view.pass.cpp b/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
index 7cb775403..0e296f209 100644
--- a/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.hash/string_view.pass.cpp
@@ -55,7 +55,7 @@ test()
     assert(sh(ss2) == h(s2));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string_view>();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -66,4 +66,6 @@ int main()
     test<std::u32string_view>();
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::wstring_view>();
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp b/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
index c721b2fcf..d4dcbdc6b 100644
--- a/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
+++ b/test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
@@ -20,7 +20,7 @@
 using std::string_view;
 using std::wstring_view;
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream out;
@@ -54,4 +54,6 @@ int main()
         assert(out.good());
         assert(L"   " + s == out.str());
     }
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.iterators/begin.pass.cpp b/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
index 0926f7f90..ba700c8ab 100644
--- a/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/begin.pass.cpp
@@ -39,7 +39,7 @@ test(S s)
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -90,4 +90,6 @@ int main()
     static_assert (   *wsv.cbegin() ==   wsv[0], "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.iterators/end.pass.cpp b/test/std/strings/string.view/string.view.iterators/end.pass.cpp
index 1287cc201..59c29e2db 100644
--- a/test/std/strings/string.view/string.view.iterators/end.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/end.pass.cpp
@@ -48,7 +48,7 @@ test(S s)
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -99,4 +99,6 @@ int main()
     static_assert (   wsv.begin() !=   wsv.cend(), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp b/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
index 43d1906c8..a57d7b454 100644
--- a/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
@@ -40,7 +40,7 @@ test(S s)
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -91,4 +91,6 @@ int main()
     static_assert (   *wsv.crbegin() ==   wsv[2], "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.iterators/rend.pass.cpp b/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
index a4eed7d97..e0db02c22 100644
--- a/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
+++ b/test/std/strings/string.view/string.view.iterators/rend.pass.cpp
@@ -48,7 +48,7 @@ test(S s)
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -99,4 +99,6 @@ int main()
     static_assert (   *--wsv.crend() ==   wsv[0], "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp b/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
index 08fe79e8f..2287ba6c8 100644
--- a/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
+++ b/test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
@@ -47,7 +47,7 @@ constexpr size_t test_ce ( size_t n, size_t k ) {
 }
 #endif
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
     test ( "", 0 );
@@ -74,4 +74,6 @@ int main () {
     static_assert ( test_ce ( 9, 3 ) == 6, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp b/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
index be9ca1e1f..0636bcea9 100644
--- a/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
+++ b/test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
@@ -47,7 +47,7 @@ constexpr size_t test_ce ( size_t n, size_t k ) {
 }
 #endif
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
     test ( "", 0 );
@@ -74,4 +74,6 @@ int main () {
     static_assert ( test_ce ( 9, 3 ) == 6, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp b/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
index 9b8eedd70..2fc286e96 100644
--- a/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
+++ b/test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
@@ -46,7 +46,7 @@ constexpr size_t test_ce ( size_t n, size_t k ) {
 #endif
 
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
     test ( "", 0 );
@@ -72,4 +72,6 @@ int main () {
     static_assert ( test_ce (0, 1) == 1, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp b/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
index f335da958..ecc24abf4 100644
--- a/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
+++ b/test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
@@ -160,7 +160,7 @@ std::wstring unquote ( const wchar_t *p, wchar_t delim='"', wchar_t escape='\\'
     return s;
 }
 
-int main()
+int main(int, char**)
 {
     round_trip    (  "" );
     round_trip_ws (  "" );
@@ -207,7 +207,11 @@ int main()
 
     assert ( unquote (  "" ) ==  "" ); // nothing there
     assert ( unquote ( L"" ) == L"" ); // nothing there
-    }
+
+    return 0;
+}
 #else
-int main() {}
+int main(int, char**) {
+  return 0;
+}
 #endif
diff --git a/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
index e9a854b34..0c04ce5e4 100644
--- a/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
@@ -32,7 +32,7 @@ test( const CharT *s1, const CharT *s2, int expected)
     test1 ( sv1, s2, expected );
 }
 
-int main()
+int main(int, char**)
 {
     {
     test("", "", 0);
@@ -123,4 +123,6 @@ int main()
     static_assert ( sv2.compare("abcde") == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
index 6f45222ff..974e68710 100644
--- a/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
@@ -354,7 +354,7 @@ void test2()
 }
 
 
-int main()
+int main(int, char**)
 {
     test0();
     test1();
@@ -449,4 +449,6 @@ int main()
     static_assert ( sv2.compare(0, 6, "abcde") == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
index 452addc12..73773fb26 100644
--- a/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
@@ -354,7 +354,7 @@ void test2()
 }
 
 
-int main () {
+int main(int, char**) {
     test0();
     test1();
     test2();
@@ -398,4 +398,6 @@ int main () {
     static_assert ( sv1.compare(2, 4, sv2) == 1, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
index d11f00331..df4e7394d 100644
--- a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
@@ -1291,7 +1291,7 @@ void test11()
     }
 
 
-int main () {
+int main(int, char**) {
     test0();
     test1();
     test2();
@@ -1349,4 +1349,6 @@ int main () {
     static_assert ( sv2.compare(0, 0, "abcde", 1, 0) == 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
index 3f6e57876..56b6ec1f4 100644
--- a/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
@@ -5747,7 +5747,7 @@ void test54()
 }
 
 
-int main () {
+int main(int, char**) {
     test0();
     test1();
     test2();
@@ -5844,4 +5844,6 @@ int main () {
     static_assert ( sv1.compare(2, 4, "abcde", 3, 4) == -1, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp b/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
index e65a7451f..9c27f2674 100644
--- a/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
@@ -34,7 +34,7 @@ void test ( const CharT *s1, const CharT  *s2, int expected ) {
     test1(sv1, sv2, expected);
 }
 
-int main () {
+int main(int, char**) {
 
     test("",                     "", 0);
     test("",                     "abcde", -5);
@@ -118,4 +118,6 @@ int main () {
     static_assert ( sv2.compare(sv3)  < 0, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.ops/copy.pass.cpp b/test/std/strings/string.view/string.view.ops/copy.pass.cpp
index 3ec48b08c..e96650992 100644
--- a/test/std/strings/string.view/string.view.ops/copy.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/copy.pass.cpp
@@ -77,7 +77,7 @@ void test ( const CharT *s ) {
 
 }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( "ABCDE");
     test ( "a" );
@@ -99,4 +99,6 @@ int main () {
     test ( U"a" );
     test ( U"" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.ops/substr.pass.cpp b/test/std/strings/string.view/string.view.ops/substr.pass.cpp
index 4391bb513..c2fd01f57 100644
--- a/test/std/strings/string.view/string.view.ops/substr.pass.cpp
+++ b/test/std/strings/string.view/string.view.ops/substr.pass.cpp
@@ -69,7 +69,7 @@ void test ( const CharT *s ) {
     test1(sv1, sv1.size() + 1, string_view_t::npos);
 }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( "ABCDE");
     test ( "a" );
@@ -117,4 +117,6 @@ int main () {
     }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp b/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
index 3f07051d0..45edec7f4 100644
--- a/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
+++ b/test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
@@ -8,4 +8,6 @@
 
 #include <string_view>
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
index c89fdb8e4..c03733074 100644
--- a/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -43,4 +43,6 @@ int main()
     static_assert (!sv2.ends_with('x'), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
index 4ef1c8e2f..64caf5cc0 100644
--- a/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@ int main()
     static_assert ( svNot.ends_with("def"), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
index 2d115c104..b5f67f8dd 100644
--- a/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@ int main()
     static_assert ( svNot.ends_with(svNot), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp b/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
index 3f07051d0..45edec7f4 100644
--- a/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
@@ -8,4 +8,6 @@
 
 #include <string_view>
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
index d35222bbf..d43944fde 100644
--- a/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -43,4 +43,6 @@ int main()
     static_assert (!sv2.starts_with('x'), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
index a3ffde5c5..ce651ec57 100644
--- a/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@ int main()
     static_assert ( svNot.starts_with("def"), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
index 5a5adbd84..3d184bae0 100644
--- a/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
+++ b/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@ int main()
     static_assert ( svNot.starts_with(svNot), "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string_view.literals/literal.pass.cpp b/test/std/strings/string.view/string_view.literals/literal.pass.cpp
index c7d0e054d..a8a1dff64 100644
--- a/test/std/strings/string.view/string_view.literals/literal.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal.pass.cpp
@@ -23,7 +23,7 @@
     typedef std::string_view   u8string_view;
 #endif
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_view_literals;
 
@@ -69,4 +69,6 @@ int main()
     static_assert(noexcept( L"ABC"sv), "");
     static_assert(noexcept( u"ABC"sv), "");
     static_assert(noexcept( U"ABC"sv), "");
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string_view.literals/literal1.fail.cpp b/test/std/strings/string.view/string_view.literals/literal1.fail.cpp
index 05e66bf1e..5bf108bbe 100644
--- a/test/std/strings/string.view/string_view.literals/literal1.fail.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal1.fail.cpp
@@ -14,9 +14,11 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::string_view;
 
     string_view foo  =   ""sv;  // should fail w/conversion operator not found
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string_view.literals/literal1.pass.cpp b/test/std/strings/string.view/string_view.literals/literal1.pass.cpp
index 956d7d26a..ba667e09c 100644
--- a/test/std/strings/string.view/string_view.literals/literal1.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal1.pass.cpp
@@ -15,10 +15,12 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
     std::string_view foo  =   ""sv;
     assert(foo.length() == 0);
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string_view.literals/literal2.fail.cpp b/test/std/strings/string.view/string_view.literals/literal2.fail.cpp
index 672201bb9..2287e1ce9 100644
--- a/test/std/strings/string.view/string_view.literals/literal2.fail.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal2.fail.cpp
@@ -14,7 +14,9 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string_view foo  =   ""sv;  // should fail w/conversion operator not found
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string_view.literals/literal2.pass.cpp b/test/std/strings/string.view/string_view.literals/literal2.pass.cpp
index 653738dc5..cb49280bf 100644
--- a/test/std/strings/string.view/string_view.literals/literal2.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal2.pass.cpp
@@ -15,10 +15,12 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_view_literals;
 
     std::string_view foo  =   ""sv;
     assert(foo.length() == 0);
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/string_view.literals/literal3.pass.cpp b/test/std/strings/string.view/string_view.literals/literal3.pass.cpp
index 814ec0cbd..710933dd9 100644
--- a/test/std/strings/string.view/string_view.literals/literal3.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal3.pass.cpp
@@ -15,10 +15,12 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std;
 
     string_view foo  =   ""sv;
     assert(foo.length() == 0);
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/traits_mismatch.fail.cpp b/test/std/strings/string.view/traits_mismatch.fail.cpp
index 6a32051a1..5cf3fa947 100644
--- a/test/std/strings/string.view/traits_mismatch.fail.cpp
+++ b/test/std/strings/string.view/traits_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <string_view>
 
-int main()
+int main(int, char**)
 {
     std::basic_string_view<char, std::char_traits<wchar_t>> s;
+
+  return 0;
 }
diff --git a/test/std/strings/string.view/types.pass.cpp b/test/std/strings/string.view/types.pass.cpp
index d8bb0f737..d90f777ba 100644
--- a/test/std/strings/string.view/types.pass.cpp
+++ b/test/std/strings/string.view/types.pass.cpp
@@ -67,7 +67,7 @@ test()
     static_assert((std::is_same<typename S::reverse_iterator, typename S::const_reverse_iterator>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::char_traits<char> >();
     test<std::char_traits<wchar_t> >();
@@ -76,4 +76,6 @@ int main()
 #endif
     static_assert((std::is_same<std::basic_string_view<char>::traits_type,
                                 std::char_traits<char> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/strings/strings.erasure/erase.pass.cpp b/test/std/strings/strings.erasure/erase.pass.cpp
index 250fe94a6..5013300d2 100644
--- a/test/std/strings/strings.erasure/erase.pass.cpp
+++ b/test/std/strings/strings.erasure/erase.pass.cpp
@@ -67,9 +67,11 @@ void test()
     test0(S("aba"), opt('c'), S("aba"));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+
+  return 0;
 }
diff --git a/test/std/strings/strings.erasure/erase_if.pass.cpp b/test/std/strings/strings.erasure/erase_if.pass.cpp
index 06b9cc227..5f2fb0117 100644
--- a/test/std/strings/strings.erasure/erase_if.pass.cpp
+++ b/test/std/strings/strings.erasure/erase_if.pass.cpp
@@ -67,9 +67,11 @@ void test()
     test0(S("aba"), True,   S(""));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+
+  return 0;
 }
diff --git a/test/std/strings/strings.general/nothing_to_do.pass.cpp b/test/std/strings/strings.general/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/strings/strings.general/nothing_to_do.pass.cpp
+++ b/test/std/strings/strings.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.async/async.fail.cpp b/test/std/thread/futures/futures.async/async.fail.cpp
index f93c3ef20..3e7fb80e0 100644
--- a/test/std/thread/futures/futures.async/async.fail.cpp
+++ b/test/std/thread/futures/futures.async/async.fail.cpp
@@ -30,8 +30,10 @@
 
 int foo (int x) { return x; }
 
-int main ()
+int main(int, char**)
 {
     std::async(                    foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::async(std::launch::async, foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.async/async.pass.cpp b/test/std/thread/futures/futures.async/async.pass.cpp
index 1083cb47d..225b63ec8 100644
--- a/test/std/thread/futures/futures.async/async.pass.cpp
+++ b/test/std/thread/futures/futures.async/async.pass.cpp
@@ -102,7 +102,7 @@ void test(CheckLamdba&& getAndCheckFn, bool IsDeferred, Args&&... args) {
     }
 }
 
-int main()
+int main(int, char**)
 {
     // The default launch policy is implementation defined. libc++ defines
     // it to be std::launch::async.
@@ -151,4 +151,5 @@ int main()
         try { f.get(); assert (false); } catch ( int ) {}
     }
 #endif
+    return 0;
 }
diff --git a/test/std/thread/futures/futures.async/async_race.38682.pass.cpp b/test/std/thread/futures/futures.async/async_race.38682.pass.cpp
index 6e115f004..826704a75 100644
--- a/test/std/thread/futures/futures.async/async_race.38682.pass.cpp
+++ b/test/std/thread/futures/futures.async/async_race.38682.pass.cpp
@@ -38,7 +38,7 @@ static int& worker_ref(int& i) { return i; }
 
 static void worker_void() { }
 
-int main() {
+int main(int, char**) {
   // future<T>
   {
     std::vector<int> const v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
@@ -65,4 +65,6 @@ int main() {
       fut.get();
     }
   }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.async/async_race.pass.cpp b/test/std/thread/futures/futures.async/async_race.pass.cpp
index 62e09723e..9da57e38a 100644
--- a/test/std/thread/futures/futures.async/async_race.pass.cpp
+++ b/test/std/thread/futures/futures.async/async_race.pass.cpp
@@ -62,6 +62,8 @@ void test_each() {
     }
 }
 
-int main() {
+int main(int, char**) {
     for (int i=0; i < 25; ++i) test_each();
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp b/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
index 1676d4bab..fbb7eb13d 100644
--- a/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
+++ b/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
@@ -17,10 +17,12 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::future_category();
     std::error_condition e_cond = e_cat.default_error_condition(static_cast<int>(std::errc::not_a_directory));
     assert(e_cond.category() == e_cat);
     assert(e_cond.value() == static_cast<int>(std::errc::not_a_directory));
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp b/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
index cb3f81393..3ba341094 100644
--- a/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
+++ b/test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
@@ -17,9 +17,11 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::future_category();
     assert(e_cat.equivalent(std::error_code(5, e_cat), 5));
     assert(!e_cat.equivalent(std::error_code(5, e_cat), 6));
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp b/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
index f39de5b11..9d0e1cf31 100644
--- a/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
+++ b/test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
@@ -17,10 +17,12 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::future_category();
     std::error_condition e_cond = e_cat.default_error_condition(5);
     assert(e_cat.equivalent(5, e_cond));
     assert(!e_cat.equivalent(6, e_cond));
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.errors/future_category.pass.cpp b/test/std/thread/futures/futures.errors/future_category.pass.cpp
index e9e784c28..7b9d72344 100644
--- a/test/std/thread/futures/futures.errors/future_category.pass.cpp
+++ b/test/std/thread/futures/futures.errors/future_category.pass.cpp
@@ -16,8 +16,10 @@
 #include <cstring>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& ec = std::future_category();
     assert(std::strcmp(ec.name(), "future") == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.errors/make_error_code.pass.cpp b/test/std/thread/futures/futures.errors/make_error_code.pass.cpp
index 9e39585c8..d9e50bf42 100644
--- a/test/std/thread/futures/futures.errors/make_error_code.pass.cpp
+++ b/test/std/thread/futures/futures.errors/make_error_code.pass.cpp
@@ -17,11 +17,13 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = make_error_code(std::future_errc::broken_promise);
         assert(ec.value() == static_cast<int>(std::future_errc::broken_promise));
         assert(ec.category() == std::future_category());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp b/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
index f8cbbdedb..d05559102 100644
--- a/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
+++ b/test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1 =
@@ -26,4 +26,6 @@ int main()
                   static_cast<int>(std::future_errc::future_already_retrieved));
         assert(ec1.category() == std::future_category());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.future_error/code.pass.cpp b/test/std/thread/futures/futures.future_error/code.pass.cpp
index 63769f018..53acba393 100644
--- a/test/std/thread/futures/futures.future_error/code.pass.cpp
+++ b/test/std/thread/futures/futures.future_error/code.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = std::make_error_code(std::future_errc::broken_promise);
@@ -53,4 +53,6 @@ int main()
         assert(f.code() == std::make_error_code(std::future_errc::no_state));
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.future_error/types.pass.cpp b/test/std/thread/futures/futures.future_error/types.pass.cpp
index 911f562e5..edf18ba5a 100644
--- a/test/std/thread/futures/futures.future_error/types.pass.cpp
+++ b/test/std/thread/futures/futures.future_error/types.pass.cpp
@@ -15,8 +15,10 @@
 #include <future>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_convertible<std::future_error*,
                                        std::logic_error*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.future_error/what.pass.cpp b/test/std/thread/futures/futures.future_error/what.pass.cpp
index bae25af1f..468aeb85b 100644
--- a/test/std/thread/futures/futures.future_error/what.pass.cpp
+++ b/test/std/thread/futures/futures.future_error/what.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::future_error f(std::make_error_code(std::future_errc::broken_promise));
@@ -50,4 +50,6 @@ int main()
         LIBCPP_ASSERT(std::strcmp(f.what(), "Operation not permitted on an object without "
                       "an associated state.") == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.overview/future_errc.pass.cpp b/test/std/thread/futures/futures.overview/future_errc.pass.cpp
index 383407d13..d7840f45c 100644
--- a/test/std/thread/futures/futures.overview/future_errc.pass.cpp
+++ b/test/std/thread/futures/futures.overview/future_errc.pass.cpp
@@ -23,7 +23,7 @@
 
 #include <future>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::future_errc::broken_promise != std::future_errc::future_already_retrieved, "");
     static_assert(std::future_errc::broken_promise != std::future_errc::promise_already_satisfied, "");
@@ -36,4 +36,6 @@ int main()
     static_assert(std::future_errc::future_already_retrieved != static_cast<std::future_errc>(0), "");
     static_assert(std::future_errc::promise_already_satisfied != static_cast<std::future_errc>(0), "");
     static_assert(std::future_errc::no_state != static_cast<std::future_errc>(0), "");
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.overview/future_status.pass.cpp b/test/std/thread/futures/futures.overview/future_status.pass.cpp
index 23c5bac06..ceff64f7e 100644
--- a/test/std/thread/futures/futures.overview/future_status.pass.cpp
+++ b/test/std/thread/futures/futures.overview/future_status.pass.cpp
@@ -19,9 +19,11 @@
 
 #include <future>
 
-int main()
+int main(int, char**)
 {
     static_assert(static_cast<int>(std::future_status::ready) == 0, "");
     static_assert(static_cast<int>(std::future_status::timeout) == 1, "");
     static_assert(static_cast<int>(std::future_status::deferred) == 2, "");
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp b/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
index f8a0d8a64..c7e2c2aeb 100644
--- a/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
+++ b/test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
@@ -15,10 +15,12 @@
 #include <future>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_error_code_enum  <std::future_errc>::value, "");
 #if TEST_STD_VER > 14
     static_assert(std::is_error_code_enum_v<std::future_errc>, "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.overview/launch.pass.cpp b/test/std/thread/futures/futures.overview/launch.pass.cpp
index 0ed166028..6d405b508 100644
--- a/test/std/thread/futures/futures.overview/launch.pass.cpp
+++ b/test/std/thread/futures/futures.overview/launch.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
    LIBCPP_STATIC_ASSERT(static_cast<int>(std::launch::any) ==
@@ -43,4 +43,6 @@ int main()
 #endif
     static_assert(static_cast<int>(std::launch::async) == 1, "");
     static_assert(static_cast<int>(std::launch::deferred) == 2, "");
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp b/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
index 1ad295220..ece8b94a5 100644
--- a/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -81,4 +81,6 @@ int main()
         std::future<void> f = p.get_future();
         assert(f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
index 895ccf7fd..bf46a6847 100644
--- a/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_assign.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@ int main()
         p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<void>'}}
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
index 00af4af49..8f90f3da7 100644
--- a/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
+++ b/test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@ int main()
         std::promise<void> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<void>'}}
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/default.pass.cpp b/test/std/thread/futures/futures.promise/default.pass.cpp
index f0e3a786d..600f99dd9 100644
--- a/test/std/thread/futures/futures.promise/default.pass.cpp
+++ b/test/std/thread/futures/futures.promise/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<int> p;
@@ -35,4 +35,6 @@ int main()
         std::future<void> f = p.get_future();
         assert(f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/dtor.pass.cpp b/test/std/thread/futures/futures.promise/dtor.pass.cpp
index 4d3bd9cb9..49c4b4685 100644
--- a/test/std/thread/futures/futures.promise/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/dtor.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -123,4 +123,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/get_future.pass.cpp b/test/std/thread/futures/futures.promise/get_future.pass.cpp
index 3805a96d0..6385f6345 100644
--- a/test/std/thread/futures/futures.promise/get_future.pass.cpp
+++ b/test/std/thread/futures/futures.promise/get_future.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<double> p;
@@ -56,4 +56,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/move_assign.pass.cpp b/test/std/thread/futures/futures.promise/move_assign.pass.cpp
index 46860fbe8..6592e0bb8 100644
--- a/test/std/thread/futures/futures.promise/move_assign.pass.cpp
+++ b/test/std/thread/futures/futures.promise/move_assign.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -93,4 +93,6 @@ int main()
         assert(test_alloc_base::alloc_count == 1);
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/move_ctor.pass.cpp b/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
index d119b188d..1551420e9 100644
--- a/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.promise/move_ctor.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -87,4 +87,6 @@ int main()
 #endif
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_exception.pass.cpp b/test/std/thread/futures/futures.promise/set_exception.pass.cpp
index bb763e9ac..030620ad4 100644
--- a/test/std/thread/futures/futures.promise/set_exception.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_exception.pass.cpp
@@ -19,7 +19,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -45,4 +45,6 @@ int main()
             assert(e.code() == make_error_code(std::future_errc::promise_already_satisfied));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
index c464d083b..a1a32882b 100644
--- a/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -24,7 +24,7 @@ void func(std::promise<int> p)
     p.set_exception_at_thread_exit(std::make_exception_ptr(3));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -41,4 +41,6 @@ int main()
             assert(i == 3);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp b/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
index 9b72e4803..db8bb5704 100644
--- a/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int& T;
@@ -44,4 +44,6 @@ int main()
         }
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
index 0fa28031d..9c3b09086 100644
--- a/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
@@ -27,7 +27,7 @@ void func(std::promise<int&> p)
     i = 4;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<int&> p;
@@ -35,4 +35,6 @@ int main()
         std::thread(func, std::move(p)).detach();
         assert(f.get() == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp b/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
index d0f2bda43..7f54baa8c 100644
--- a/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
@@ -26,7 +26,7 @@ struct A
     A(A&&) {throw 9;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unique_ptr<int> T;
@@ -60,4 +60,6 @@ int main()
             assert(j == 9);
         }
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
index a5574238d..bddd66135 100644
--- a/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
@@ -23,7 +23,7 @@ void func(std::promise<std::unique_ptr<int>> p)
     p.set_value_at_thread_exit(std::unique_ptr<int>(new int(5)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<std::unique_ptr<int>> p;
@@ -31,4 +31,6 @@ int main()
         std::thread(func, std::move(p)).detach();
         assert(*f.get() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
index 476061177..9258a0011 100644
--- a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
@@ -24,7 +24,7 @@ void func(std::promise<int> p)
     p.set_value_at_thread_exit(i);
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<int> p;
@@ -32,4 +32,6 @@ int main()
         std::thread(func, std::move(p)).detach();
         assert(f.get() == 5);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
index e2b8ae9a5..1a204421e 100644
--- a/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
@@ -27,7 +27,7 @@ void func(std::promise<void> p)
     i = 1;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<void> p;
@@ -36,4 +36,6 @@ int main()
         f.get();
         assert(i == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_value_const.pass.cpp b/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
index 942481542..e58d2d245 100644
--- a/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_const.pass.cpp
@@ -28,7 +28,7 @@ struct A
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -68,4 +68,6 @@ int main()
         }
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/set_value_void.pass.cpp b/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
index 330d5b025..d505b3aab 100644
--- a/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
+++ b/test/std/thread/futures/futures.promise/set_value_void.pass.cpp
@@ -19,7 +19,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef void T;
@@ -37,4 +37,6 @@ int main()
             assert(e.code() == make_error_code(std::future_errc::promise_already_satisfied));
         }
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/swap.pass.cpp b/test/std/thread/futures/futures.promise/swap.pass.cpp
index ec72f8794..2b78b1d38 100644
--- a/test/std/thread/futures/futures.promise/swap.pass.cpp
+++ b/test/std/thread/futures/futures.promise/swap.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -81,4 +81,6 @@ int main()
         assert(test_alloc_base::alloc_count == 1);
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp b/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
index 928ede9fb..1a5028bce 100644
--- a/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
@@ -19,9 +19,11 @@
 #include <future>
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::uses_allocator<std::promise<int>, test_allocator<int> >::value), "");
     static_assert((std::uses_allocator<std::promise<int&>, test_allocator<int> >::value), "");
     static_assert((std::uses_allocator<std::promise<void>, test_allocator<void> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp b/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
index 44c538c97..e5cc33a0c 100644
--- a/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -77,4 +77,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp b/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
index 2878c40d1..01b5572e3 100644
--- a/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -71,4 +71,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp b/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
index 10b84a411..b75450cb9 100644
--- a/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -65,4 +65,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/default.pass.cpp b/test/std/thread/futures/futures.shared_future/default.pass.cpp
index 2229ee58e..0387b97a7 100644
--- a/test/std/thread/futures/futures.shared_future/default.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/default.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_future<int> f;
@@ -31,4 +31,6 @@ int main()
         std::shared_future<void> f;
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/dtor.pass.cpp b/test/std/thread/futures/futures.shared_future/dtor.pass.cpp
index 964180b98..fe49c2208 100644
--- a/test/std/thread/futures/futures.shared_future/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/dtor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -66,4 +66,6 @@ int main()
         assert(f.valid());
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/get.pass.cpp b/test/std/thread/futures/futures.shared_future/get.pass.cpp
index b7767b379..038ca7151 100644
--- a/test/std/thread/futures/futures.shared_future/get.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/get.pass.cpp
@@ -61,7 +61,7 @@ void func6(std::promise<void> p)
     p.set_exception(std::make_exception_ptr('c'));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -150,4 +150,6 @@ int main()
         }
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp b/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
index b68ee6921..394053052 100644
--- a/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -71,4 +71,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp b/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
index c2b52dc1b..e1d982d0e 100644
--- a/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -65,4 +65,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/wait.pass.cpp b/test/std/thread/futures/futures.shared_future/wait.pass.cpp
index 11dc4ba3d..f78ca6bfc 100644
--- a/test/std/thread/futures/futures.shared_future/wait.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait.pass.cpp
@@ -39,7 +39,7 @@ void func5(std::promise<void> p)
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     typedef std::chrono::duration<double, std::milli> ms;
@@ -85,4 +85,6 @@ int main()
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp b/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
index 4fbd8ae79..913127af3 100644
--- a/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
@@ -43,7 +43,7 @@ void func5(std::promise<void> p)
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -94,4 +94,6 @@ int main()
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
index 02b0ce716..09787fedc 100644
--- a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
@@ -62,7 +62,7 @@ void func5(std::promise<void> p)
     set_worker_thread_state(WorkerThreadState::Exiting);
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -128,4 +128,6 @@ int main()
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp b/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
+++ b/test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
index b14f2381a..a8b858189 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
@@ -17,10 +17,12 @@
 
 #include <future>
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
index 655a9d7f8..9da7a96e2 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
@@ -28,7 +28,7 @@ public:
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -47,4 +47,6 @@ int main()
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
index fbe3b55a8..ec081dc32 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
@@ -25,11 +25,13 @@ typedef std::packaged_task<A(int, char)> PT;
 typedef volatile std::packaged_task<A(int, char)> VPT;
 
 
-int main()
+int main(int, char**)
 {
     VPT init{};
     auto const& c_init = init;
     PT p1{init}; // expected-error {{no matching constructor}}
     PT p2{c_init}; // expected-error {{no matching constructor}}
     PT p3{std::move(init)}; // expected-error {{no matching constructor for initialization of 'PT' (aka 'packaged_task<A (int, char)>')}}
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
index cae4e1afd..76273a3ea 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
@@ -26,8 +26,10 @@ struct A {};
 typedef std::packaged_task<A(int, char)> PT;
 typedef volatile std::packaged_task<A(int, char)> VPT;
 
-int main()
+int main(int, char**)
 {
     PT p { std::allocator_arg_t{}, test_allocator<A>{}, VPT {}}; // expected-error {{no matching constructor for initialization of 'PT' (aka 'packaged_task<A (int, char)>')}}
     // expected-note-re@future:* 1 {{candidate template ignored: {{(disabled by 'enable_if')|(requirement '.*' was not satisfied)}}}}
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
index 6416df4de..0816a1cc5 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
@@ -18,10 +18,12 @@
 #include <future>
 
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0;
         std::packaged_task<double(int, char)> p(p0); // expected-error {{call to deleted constructor of 'std::packaged_task<double (int, char)>'}}
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
index 30c45eaab..5472c717a 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
@@ -20,8 +20,10 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     std::packaged_task<A(int, char)> p;
     assert(!p.valid());
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
index 3da276ba8..20ee8b4b4 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
@@ -39,7 +39,7 @@ int A::n_copies = 0;
 
 int func(int i) { return i; }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -76,4 +76,6 @@ int main()
         p(4);
         assert(f.get() == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
index 334ed8f98..766987ce0 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
@@ -44,7 +44,7 @@ int A::n_copies = 0;
 
 int func(int i) { return i; }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(std::allocator_arg,
@@ -123,4 +123,6 @@ int main()
     }
     A::n_copies = 0;
     A::n_moves  = 0;
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
index e2e44473e..c517182d3 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
@@ -28,7 +28,7 @@ public:
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -45,4 +45,6 @@ int main()
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
index e910d7c4c..3b794b7f6 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
@@ -39,7 +39,7 @@ void func2(std::packaged_task<double(int, char)> p)
     p(3, 'a');
 }
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
@@ -64,4 +64,6 @@ int main()
         std::thread(func2, std::move(p)).detach();
         assert(f.get() == 105.0);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
index a4c9c7af4..8713db0a7 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
@@ -30,7 +30,7 @@ public:
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -65,4 +65,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
index 21a567ca0..470099522 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
@@ -80,7 +80,7 @@ void func3(std::packaged_task<double(int, char)> p)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -115,4 +115,6 @@ int main()
         t.join();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
index e148ddfc9..536888057 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
@@ -80,7 +80,7 @@ void func3(std::packaged_task<double(int, char)> p)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -116,4 +116,6 @@ int main()
         t.join();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
index 7e4dd5522..e9f59cdfe 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
@@ -33,7 +33,7 @@ public:
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -59,4 +59,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
index 22e680f2a..2cd97900d 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
@@ -28,7 +28,7 @@ public:
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -47,4 +47,6 @@ int main()
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
index b344398fe..8c1c19eca 100644
--- a/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
@@ -30,7 +30,7 @@ public:
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -49,4 +49,6 @@ int main()
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
index 24727b5d3..5257a7008 100644
--- a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
@@ -27,7 +27,9 @@
 #include <future>
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::uses_allocator<std::packaged_task<double(int, char)>, test_allocator<int> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp b/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
index 63e92f021..3a1a4d6be 100644
--- a/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
+++ b/test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@ int main()
         f = f0; // expected-error {{'operator=' is a private member of 'std::__1::future<void>'}}
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp b/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
index 0d1a5884b..4a8b98c19 100644
--- a/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
+++ b/test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@ int main()
         std::future<void> f = f0; // expected-error {{calling a private constructor of class 'std::__1::future<void>'}}
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/default.pass.cpp b/test/std/thread/futures/futures.unique_future/default.pass.cpp
index 0f11aa334..60ef645e3 100644
--- a/test/std/thread/futures/futures.unique_future/default.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/default.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::future<int> f;
@@ -31,4 +31,6 @@ int main()
         std::future<void> f;
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/dtor.pass.cpp b/test/std/thread/futures/futures.unique_future/dtor.pass.cpp
index 4105d3f90..ec27219da 100644
--- a/test/std/thread/futures/futures.unique_future/dtor.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/dtor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -66,4 +66,6 @@ int main()
         assert(f.valid());
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/get.pass.cpp b/test/std/thread/futures/futures.unique_future/get.pass.cpp
index 3d50d896a..2e3e32648 100644
--- a/test/std/thread/futures/futures.unique_future/get.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/get.pass.cpp
@@ -61,7 +61,7 @@ void func6(std::promise<void> p)
     p.set_exception(std::make_exception_ptr('c'));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -150,4 +150,6 @@ int main()
         }
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp b/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
index 7d2ad6218..b0f0e2b5c 100644
--- a/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -70,4 +70,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp b/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
index 0b0e4913c..aca5dda64 100644
--- a/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/share.pass.cpp b/test/std/thread/futures/futures.unique_future/share.pass.cpp
index 392a43a47..979f93ccc 100644
--- a/test/std/thread/futures/futures.unique_future/share.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/share.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -71,4 +71,6 @@ int main()
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/wait.pass.cpp b/test/std/thread/futures/futures.unique_future/wait.pass.cpp
index 0ec23f27e..11fc80868 100644
--- a/test/std/thread/futures/futures.unique_future/wait.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/wait.pass.cpp
@@ -39,7 +39,7 @@ void func5(std::promise<void> p)
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     typedef std::chrono::duration<double, std::milli> ms;
@@ -85,4 +85,6 @@ int main()
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp b/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
index 5b8a01aaf..91f962fd1 100644
--- a/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
@@ -43,7 +43,7 @@ void func5(std::promise<void> p)
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -94,4 +94,6 @@ int main()
         assert(f.valid());
         assert(t1-t0 < ms(50));
     }
+
+  return 0;
 }
diff --git a/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp b/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
index 79da1c0e3..28d9b638a 100644
--- a/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
+++ b/test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
@@ -60,7 +60,7 @@ void func5(std::promise<void> p)
     set_worker_thread_state(WorkerThreadState::Exiting);
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -126,4 +126,6 @@ int main()
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
diff --git a/test/std/thread/macro.pass.cpp b/test/std/thread/macro.pass.cpp
index bfae0bbee..640db4aaa 100644
--- a/test/std/thread/macro.pass.cpp
+++ b/test/std/thread/macro.pass.cpp
@@ -14,9 +14,11 @@
 
 #include <thread>
 
-int main()
+int main(int, char**)
 {
 #ifndef __STDCPP_THREADS__
 #error __STDCPP_THREADS__ is not defined
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/cv_status.pass.cpp b/test/std/thread/thread.condition/cv_status.pass.cpp
index af8a10ada..af980c3ee 100644
--- a/test/std/thread/thread.condition/cv_status.pass.cpp
+++ b/test/std/thread/thread.condition/cv_status.pass.cpp
@@ -15,8 +15,10 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(static_cast<int>(std::cv_status::no_timeout) == 0);
     assert(static_cast<int>(std::cv_status::timeout)    == 1);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp b/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
index 22fbc98e2..9a0e51e3b 100644
--- a/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
+++ b/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
@@ -36,7 +36,7 @@ void func()
     std::this_thread::sleep_for(ms(300));
 }
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk(mut);
     std::thread t(func);
@@ -45,4 +45,6 @@ int main()
     Clock::time_point t1 = Clock::now();
     assert(t1-t0 > ms(250));
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
index e308b20e8..a367051fe 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable cv0;
     std::condition_variable cv1;
     cv1 = cv0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
index d0c4c653d..f9d607657 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
@@ -15,8 +15,10 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable cv0;
     std::condition_variable cv1(cv0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
index 879d3c7dc..aab97f9e1 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
@@ -17,7 +17,9 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable cv;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
index 85c83f92a..6550109fd 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
@@ -43,7 +43,7 @@ void g()
         cv->wait(lk);
 }
 
-int main()
+int main(int, char**)
 {
     cv = new std::condition_variable;
     std::thread th2(g);
@@ -54,4 +54,6 @@ int main()
     std::thread th1(f);
     th1.join();
     th2.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
index c281a9d20..46c53a863 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
@@ -46,7 +46,7 @@ void f2()
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -65,4 +65,6 @@ int main()
     t2.join();
     assert(test1 == 2);
     assert(test2 == 2);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
index f72d36e8a..eb1de67db 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
@@ -47,7 +47,7 @@ void f2()
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -95,4 +95,6 @@ int main()
     }
     else
         assert(false);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
index a34207406..03bcfeea9 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
@@ -36,7 +36,7 @@ void f()
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex>lk(mut);
     std::thread t(f);
@@ -48,4 +48,6 @@ int main()
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
index f34b230c2..505997fff 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
@@ -59,7 +59,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -85,4 +85,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
index a61b000bd..e92ce4583 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
@@ -66,7 +66,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -92,4 +92,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
index f99436a5e..0de8524ed 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
@@ -46,7 +46,7 @@ void f()
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex>lk(mut);
     std::thread t(f);
@@ -58,4 +58,6 @@ int main()
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
index f954ae25e..7f1bdf827 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
@@ -72,7 +72,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -98,4 +98,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
index 8307a52c0..f21b1b54b 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
@@ -85,7 +85,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -111,4 +111,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
index 214164ea7..0c2adc9a5 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable_any cv0;
     std::condition_variable_any cv1;
     cv1 = cv0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
index 6eafc6202..5aff93ba0 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
@@ -15,8 +15,10 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable_any cv0;
     std::condition_variable_any cv1(cv0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
index 05ebff068..0c35da032 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
@@ -17,7 +17,9 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable_any cv;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
index 57b3024fe..35580d429 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
@@ -44,7 +44,7 @@ void g()
     m.unlock();
 }
 
-int main()
+int main(int, char**)
 {
     cv = new std::condition_variable_any;
     std::thread th2(g);
@@ -55,4 +55,6 @@ int main()
     std::thread th1(f);
     th1.join();
     th2.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
index cb79d8a6b..d12c93602 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
@@ -50,7 +50,7 @@ void f2()
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -69,4 +69,6 @@ int main()
     t2.join();
     assert(test1 == 2);
     assert(test2 == 2);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
index e5c0a0943..27a0f87e5 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
@@ -52,7 +52,7 @@ void f2()
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -96,4 +96,6 @@ int main()
     }
     else
         assert(false);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
index 741094bdd..a3b2e87c9 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
@@ -41,7 +41,7 @@ void f()
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     L1 lk(m0);
     std::thread t(f);
@@ -53,4 +53,6 @@ int main()
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
index ec4eb3398..d472a698f 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
@@ -62,7 +62,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         L1 lk(m0);
@@ -88,4 +88,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
index 81d69861f..cbf0193ad 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
@@ -70,7 +70,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         expect_result = true;
@@ -98,4 +98,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
index d76cbd443..eafc434d0 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
@@ -50,7 +50,7 @@ void f()
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     L1 lk(m0);
     std::thread t(f);
@@ -62,4 +62,6 @@ int main()
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
index 796b66e99..8afa05159 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
@@ -109,7 +109,7 @@ void signal_me() {
 typedef std::chrono::system_clock Clock;
 typedef std::chrono::milliseconds MS;
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
   assert(argc == 2);
   int id = std::stoi(argv[1]);
   assert(id >= 1 && id <= 6);
@@ -130,4 +130,6 @@ int main(int argc, char** argv) {
     }
   } catch (...) {}
   assert(false);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
index 276597350..e14944906 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
@@ -75,7 +75,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         L1 lk(m0);
@@ -101,4 +101,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
index 0216688d7..5eb253a75 100644
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
@@ -89,7 +89,7 @@ void f()
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         L1 lk(m0);
@@ -115,4 +115,6 @@ int main()
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.general/nothing_to_do.pass.cpp b/test/std/thread/thread.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.general/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
index 1c7de8349..207b0753e 100644
--- a/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
@@ -92,7 +92,7 @@ public:
     bool locked() const {return locked_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         L0 l0;
@@ -518,4 +518,6 @@ int main()
     }
 #endif  // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
index 7856ab96f..50ff29ce9 100644
--- a/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
@@ -72,7 +72,7 @@ public:
     bool locked() const {return locked_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         L0 l0;
@@ -522,4 +522,6 @@ int main()
         assert(!l3.locked());
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
index 273a48813..fc76eb34e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
@@ -42,11 +42,13 @@ void f()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
index b22e0db9e..2d0f438ed 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
@@ -14,11 +14,13 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m0;
     std::mutex m1;
     std::lock_guard<std::mutex> lg0(m0);
     std::lock_guard<std::mutex> lg(m1);
     lg = lg0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
index 1852db1e5..e99517e47 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m;
     std::lock_guard<std::mutex> lg0(m);
     std::lock_guard<std::mutex> lg(lg0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
index 52a0397de..383c1539a 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
@@ -16,8 +16,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m;
     std::lock_guard<std::mutex> lg = m; // expected-error{{no viable conversion}}
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
index 84353486b..fa6aa4615 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
@@ -46,7 +46,7 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
@@ -58,4 +58,6 @@ int main()
     std::lock_guard lg(m);
     static_assert((std::is_same<decltype(lg), std::lock_guard<decltype(m)>>::value), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
index 745633b55..b9cdb4dec 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
@@ -21,8 +21,10 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::lock_guard<std::mutex>::mutex_type,
                    std::mutex>::value), "");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
index edaf09c5a..63e0626d5 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
@@ -31,7 +31,7 @@ struct TestMutex {
     TestMutex& operator=(TestMutex const&) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using LG = std::scoped_lock<>;
@@ -68,4 +68,6 @@ int main()
         assert(!m1.locked && !m2.locked && !m3.locked);
     }
 
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
index d88b4dedc..66a68bb27 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
@@ -18,7 +18,7 @@
 #include <mutex>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
@@ -46,4 +46,6 @@ int main()
         LG lg2(om0, om1, om2);
         lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
index 16938731b..3829d15a6 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
@@ -18,7 +18,7 @@
 #include <mutex>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
@@ -42,4 +42,6 @@ int main()
         const LG Orig(m0, m1, m2);
         LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
index 4f25ec237..0c9258887 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
@@ -21,7 +21,7 @@
 template <class LG>
 void test_conversion(LG) {}
 
-int main()
+int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
@@ -49,4 +49,6 @@ int main()
         LG lg = {m0, m1, m2}; // expected-error{{chosen constructor is explicit in copy-initialization}}
         test_conversion<LG>({n0, n1, n2}); // expected-error{{no matching function for call}}
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
index 219c389aa..3a633c39b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
@@ -61,7 +61,7 @@ struct TestMutexThrows {
 };
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
 
-int main()
+int main(int, char**)
 {
     {
         using LG = std::scoped_lock<>;
@@ -151,4 +151,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
index 5228ccead..62621fcca 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
@@ -36,7 +36,7 @@ constexpr bool has_mutex_type() {
     return !std::is_same<decltype(test_typedef<LG>(0)), NAT>::value;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using T = std::scoped_lock<>;
@@ -74,4 +74,6 @@ int main()
         using T = std::scoped_lock<M1, M1, M1>;
         static_assert(!has_mutex_type<T>(), "");
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
index ff6c376da..1b31fbc50 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
@@ -18,9 +18,11 @@
 std::shared_timed_mutex m0;
 std::shared_timed_mutex m1;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0(m0);
     std::shared_lock<std::shared_timed_mutex> lk1(m1);
     lk1 = lk0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
index 6f1f2e9ab..48da3c715 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
@@ -17,8 +17,10 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0(m);
     std::shared_lock<std::shared_timed_mutex> lk = lk0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
index 2d571cb51..0543ae72e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
@@ -18,9 +18,11 @@
 #include <shared_mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> ul;
     assert(!ul.owns_lock());
     assert(ul.mutex() == nullptr);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
index 960948421..999d65f02 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
@@ -20,7 +20,7 @@
 #include "nasty_containers.hpp"
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -46,4 +46,6 @@ int main()
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
index 6be2e774b..1f61e21fb 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -41,4 +41,6 @@ int main()
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
index 1204eb1f0..14c084f00 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
@@ -71,7 +71,7 @@ void g()
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<std::thread> v;
     {
@@ -99,4 +99,6 @@ int main()
     std::shared_lock sl(m);
     static_assert((std::is_same<decltype(sl), std::shared_lock<decltype(m)>>::value), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
index 2b5fae21b..86d54b508 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -37,4 +37,6 @@ int main()
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
index c7d0a192b..5a085d2e6 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -35,4 +35,6 @@ int main()
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
index f633c2e8c..3228f938f 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
@@ -66,7 +66,7 @@ void f2()
     assert(d < Tolerance);  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -88,4 +88,6 @@ int main()
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
index c899cea3e..f62e73944 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
@@ -65,7 +65,7 @@ void f2()
     assert(d < Tolerance);  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -87,4 +87,6 @@ int main()
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
index 4375a2b99..7dd7c16fe 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
@@ -57,7 +57,7 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -67,4 +67,6 @@ int main()
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
index 7726337c8..5f084b212 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
@@ -80,7 +80,7 @@ void f()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -90,4 +90,6 @@ int main()
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
index 884dd47b0..488260618 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
@@ -34,7 +34,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
@@ -67,4 +67,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
index e6df4f121..b2c177683 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
@@ -39,7 +39,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
@@ -72,4 +72,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
index 74e0ecc23..59bcd4a0b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
@@ -38,7 +38,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock Clock;
     std::shared_lock<mutex> lk(m, std::defer_lock);
@@ -72,4 +72,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
index 6c100470e..b0e337bda 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
@@ -30,7 +30,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m);
     lk.unlock();
@@ -59,4 +59,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
index 22eb3ee48..ce385ddbd 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
@@ -26,7 +26,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk1(m);
     std::shared_lock<mutex> lk2;
@@ -36,4 +36,6 @@ int main()
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
     static_assert(noexcept(lk1.swap(lk2)), "member swap must be noexcept");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
index 65e05d39f..cec13f0f2 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
@@ -27,7 +27,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk1(m);
     std::shared_lock<mutex> lk2;
@@ -37,4 +37,6 @@ int main()
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
     static_assert(noexcept(swap(lk1, lk2)), "non-member swap must be noexcept");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
index d387a8351..f2e5820cf 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
@@ -31,7 +31,7 @@ int mutex::unlock_count = 0;
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m);
     assert(lk.mutex() == &m);
@@ -44,4 +44,6 @@ int main()
     assert(mutex::lock_count == 1);
     assert(mutex::unlock_count == 0);
     static_assert(noexcept(lk.release()), "release must be noexcept");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
index 28685954b..867bae0e3 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
@@ -20,7 +20,7 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0;
     assert(lk0.mutex() == nullptr);
@@ -29,4 +29,6 @@ int main()
     lk1.unlock();
     assert(lk1.mutex() == &m);
     static_assert(noexcept(lk0.mutex()), "mutex() must be noexcept");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
index 1064d727c..82d737ee5 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
@@ -20,7 +20,7 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0;
     assert(static_cast<bool>(lk0) == false);
@@ -29,4 +29,6 @@ int main()
     lk1.unlock();
     assert(static_cast<bool>(lk1) == false);
     static_assert(noexcept(static_cast<bool>(lk0)), "explicit operator bool() must be noexcept");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
index 36a2c0f83..f949684e8 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
@@ -20,7 +20,7 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0;
     assert(lk0.owns_lock() == false);
@@ -29,4 +29,6 @@ int main()
     lk1.unlock();
     assert(lk1.owns_lock() == false);
     static_assert(noexcept(lk0.owns_lock()), "owns_lock must be noexcept");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
index c5be52afe..44d19e8db 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
@@ -23,8 +23,10 @@
 #include <shared_mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::shared_lock<std::mutex>::mutex_type,
                    std::mutex>::value), "");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
index 057991046..799cb61f9 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
@@ -15,7 +15,7 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -29,4 +29,6 @@ int main()
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
index 12045f998..e258198e6 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
@@ -15,7 +15,7 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -27,4 +27,6 @@ int main()
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
index 46f4f1e80..74b265141 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
@@ -17,9 +17,11 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> ul;
     assert(!ul.owns_lock());
     assert(ul.mutex() == nullptr);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
index 16b1bd8c5..1e663766b 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -44,4 +44,6 @@ int main()
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
index 2c4993702..8ea0a1f2d 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -40,4 +40,6 @@ int main()
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
index 30897b3d8..61c0dacf1 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
@@ -46,7 +46,7 @@ void f()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
@@ -58,4 +58,6 @@ int main()
     std::unique_lock ul(m);
     static_assert((std::is_same<decltype(ul), std::unique_lock<decltype(m)>>::value), "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
index 1c258d6a6..d957c6d24 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -36,4 +36,6 @@ int main()
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
index 5f4ab4e74..af6853160 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -34,4 +34,6 @@ int main()
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
index 8fee76b8f..8699dd554 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
@@ -50,7 +50,7 @@ void f2()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -66,4 +66,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
index 4cd2efeba..ab46dacad 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
@@ -50,7 +50,7 @@ void f2()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -66,4 +66,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
index 3c385808b..448be8e7e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
@@ -53,11 +53,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
index 536a0d7d2..b8a0c2d34 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
@@ -66,11 +66,13 @@ void f()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
index cfc0befca..a6247df7e 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
@@ -33,7 +33,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
@@ -66,4 +66,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
index f1a2ef6c4..a6166ceda 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
@@ -38,7 +38,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
@@ -71,4 +71,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
index 60616da93..6c7da1c0c 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
@@ -37,7 +37,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock Clock;
     std::unique_lock<mutex> lk(m, std::defer_lock);
@@ -71,4 +71,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
index bb0c00ded..1f0a0e529 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
@@ -29,7 +29,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m);
     lk.unlock();
@@ -58,4 +58,6 @@ int main()
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
index 3c89d6cf8..707755f59 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
@@ -25,7 +25,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk1(m);
     std::unique_lock<mutex> lk2;
@@ -34,4 +34,6 @@ int main()
     assert(lk1.owns_lock() == false);
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
index ea99ba9e5..1c05657d6 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
@@ -26,7 +26,7 @@ struct mutex
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk1(m);
     std::unique_lock<mutex> lk2;
@@ -35,4 +35,6 @@ int main()
     assert(lk1.owns_lock() == false);
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
index 9dc9ec3a1..9751149b9 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
@@ -30,7 +30,7 @@ int mutex::unlock_count = 0;
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m);
     assert(lk.mutex() == &m);
@@ -42,4 +42,6 @@ int main()
     assert(lk.owns_lock() == false);
     assert(mutex::lock_count == 1);
     assert(mutex::unlock_count == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
index 6e6fb6b76..899f965df 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
@@ -19,7 +19,7 @@
 
 std::mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk0;
     assert(lk0.mutex() == nullptr);
@@ -27,4 +27,6 @@ int main()
     assert(lk1.mutex() == &m);
     lk1.unlock();
     assert(lk1.mutex() == &m);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
index 184bc71f5..1affe8deb 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
@@ -19,7 +19,7 @@
 
 std::mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk0;
     assert(static_cast<bool>(lk0) == false);
@@ -27,4 +27,6 @@ int main()
     assert(static_cast<bool>(lk1) == true);
     lk1.unlock();
     assert(static_cast<bool>(lk1) == false);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
index 68f944e26..2c5496b29 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
@@ -19,7 +19,7 @@
 
 std::mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk0;
     assert(lk0.owns_lock() == false);
@@ -27,4 +27,6 @@ int main()
     assert(lk1.owns_lock() == true);
     lk1.unlock();
     assert(lk1.owns_lock() == false);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
index 44b1265e7..7dc093ac6 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
@@ -21,8 +21,10 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::unique_lock<std::mutex>::mutex_type,
                    std::mutex>::value), "");
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/types.pass.cpp b/test/std/thread/thread.mutex/thread.lock/types.pass.cpp
index 8d6a1fbce..150d9b4aa 100644
--- a/test/std/thread/thread.mutex/thread.lock/types.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::defer_lock_t T1;
     typedef std::try_to_lock_t T2;
@@ -30,4 +30,6 @@ int main()
     T1 t1 = std::defer_lock; ((void)t1);
     T2 t2 = std::try_to_lock; ((void)t2);
     T3 t3 = std::adopt_lock; ((void)t3);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
index d2d34a289..ba09ed1a7 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m0;
     std::mutex m1;
     m1 = m0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
index 5e1f17dc1..9edfb7267 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m0;
     std::mutex m1(m0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
index aa8a34b07..b5a608eeb 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
@@ -17,8 +17,10 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_nothrow_default_constructible<std::mutex>::value, "");
     std::mutex m;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
index 912b647d3..dcb4b8ff8 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
@@ -41,11 +41,13 @@ void f()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
index 9d3d53dab..712215583 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
@@ -41,11 +41,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
index 613eae74d..0cf3c5bca 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m0;
     std::recursive_mutex m1;
     m1 = m0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
index 812951b46..454d77973 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m0;
     std::recursive_mutex m1(m0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
index 9c63a8037..e32c92f0c 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
@@ -16,7 +16,9 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
index 0342b4c2c..f8744a9b7 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
@@ -41,11 +41,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
index b5b256566..092343fe7 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
@@ -43,11 +43,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
index 6b589f97d..337fcdf08 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
@@ -17,9 +17,11 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_mutex m0;
     std::shared_mutex m1;
     m1 = m0; // expected-error {{overload resolution selected deleted operator '='}}
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
index 0c4fb55f1..93d02885a 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
@@ -17,8 +17,10 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_mutex m0;
     std::shared_mutex m1(m0); // expected-error {{call to deleted constructor of 'std::shared_mutex'}}
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
index ac8b9b076..ecd29b748 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
@@ -17,7 +17,9 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_mutex m;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
index 3eb434a80..74c66d0f6 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
@@ -53,11 +53,13 @@ void f()
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(WaitTime);
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
index 38be785c8..7707af8d8 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
@@ -65,7 +65,7 @@ void g()
 }
 
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -84,4 +84,6 @@ int main()
     for (auto& t : v)
         t.join();
     q.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
index fff58b1ff..09c7ad5f0 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
@@ -42,11 +42,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
index 26bf18868..b9538b564 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
@@ -46,7 +46,7 @@ void f()
 }
 
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -56,4 +56,6 @@ int main()
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
index c710e0510..483111db9 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
@@ -15,9 +15,11 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_timed_mutex m0;
     std::shared_timed_mutex m1;
     m1 = m0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
index dba5e3114..7483b1f51 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
@@ -15,8 +15,10 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_timed_mutex m0;
     std::shared_timed_mutex m1(m0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
index 8fe432fc1..83b30b98d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
@@ -17,7 +17,9 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_timed_mutex m;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
index c3be2b616..56464b240 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
@@ -55,11 +55,13 @@ void f()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
index 0702ba01c..08d35861e 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
@@ -67,7 +67,7 @@ void g()
 }
 
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -86,4 +86,6 @@ int main()
     for (auto& t : v)
         t.join();
     q.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
index 4927c3654..6b2d9a543 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
@@ -42,11 +42,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
index d2a24fb81..45fea3e96 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
@@ -64,7 +64,7 @@ void f2()
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -80,4 +80,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
index 7e0886de4..830445af9 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
@@ -54,7 +54,7 @@ void f()
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -64,4 +64,6 @@ int main()
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
index 250ff9be9..d89e4aa8c 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
@@ -64,7 +64,7 @@ void f2()
     assert(d < Tolerance);  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -86,4 +86,6 @@ int main()
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
index de6c58463..5898fe41e 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
@@ -64,7 +64,7 @@ void f2()
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -86,4 +86,6 @@ int main()
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
index 40cdfe844..9539215c4 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
@@ -64,7 +64,7 @@ void f2()
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -80,4 +80,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
index fb766e161..865ab9254 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
@@ -47,7 +47,7 @@ void blocked_reader() {
   m.unlock_shared();
 }
 
-int main()
+int main(int, char**)
 {
   typedef std::chrono::steady_clock Clock;
 
@@ -66,4 +66,6 @@ int main()
   t1.join();
   t2.join();
   t3.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
index 902b5ec42..d0fabc678 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::timed_mutex m0;
     std::timed_mutex m1;
     m1 = m0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
index 803b330d6..a3efb2fee 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::timed_mutex m0;
     std::timed_mutex m1(m0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
index aae979043..c879f192e 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
@@ -16,7 +16,9 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::timed_mutex m;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
index 7b351829a..8ef3a8347 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
@@ -39,11 +39,13 @@ void f()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
index d61f62635..7398b7f6d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
@@ -41,11 +41,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
index 2e050d917..0103cdf64 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
@@ -47,7 +47,7 @@ void f2()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -63,4 +63,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
index adf711593..350bb767d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
@@ -47,7 +47,7 @@ void f2()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -63,4 +63,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
index e34b2b998..44be06d67 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_timed_mutex m0;
     std::recursive_timed_mutex m1;
     m1 = m0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
index cbdd2eb63..154a0192d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_timed_mutex m0;
     std::recursive_timed_mutex m1(m0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
index 98de22ecc..ee6124c02 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
@@ -16,7 +16,9 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_timed_mutex m;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
index aba747b95..adb54872e 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
@@ -43,11 +43,13 @@ void f()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
index 9d73bb57f..05b22c0de 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
@@ -43,11 +43,13 @@ void f()
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
index feab81495..9e5ad5ee9 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
@@ -49,7 +49,7 @@ void f2()
     assert(d < ns(50000000));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -65,4 +65,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
index b795315b2..f6b9d106a 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
@@ -49,7 +49,7 @@ void f2()
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -65,4 +65,6 @@ int main()
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp b/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
index be5056e40..398ee058c 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
@@ -186,7 +186,7 @@ struct RefQual
 
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     // check basic functionality
     {
@@ -253,4 +253,6 @@ int main()
         assert(rq.rv_called == 1);
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
index ebba7f3d4..511aa3e80 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
@@ -37,11 +37,13 @@ void f0()
     assert(global == 1);
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t0(f0);
     std::thread t1(f0);
     t0.join();
     t1.join();
     assert(global == 1);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
index dd6fe09c3..40d408d54 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::once_flag f;
     std::once_flag f2;
     f2 = f;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
index ca428ffb4..9b7c19a96 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::once_flag f;
     std::once_flag f2(f);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
index 4a1655ffe..28d93dc7f 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
@@ -15,7 +15,7 @@
 #include <mutex>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::once_flag f;
@@ -27,4 +27,6 @@ int main()
     (void)f;
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/nothing_to_do.pass.cpp b/test/std/thread/thread.req/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp b/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
+++ b/test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
index 64a413686..68f20d753 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
@@ -41,7 +41,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -54,4 +54,6 @@ int main()
         assert(t1.get_id() == id0);
         t1.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
index 1afaaf7bd..e67ceea5d 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
@@ -40,11 +40,13 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         std::thread t0(G());
         std::thread t1;
         t1 = t0;
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
index e2f3d38fc..cbc32c8c2 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
@@ -41,7 +41,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         assert(G::n_alive == 0);
@@ -59,4 +59,6 @@ int main()
         assert(G::n_alive == 0);
         assert(G::op_run);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
index 9a4d6e910..81c6d77e8 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
@@ -51,7 +51,7 @@ void f1()
     std::_Exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     {
@@ -61,4 +61,6 @@ int main()
         t0 = std::move(t1);
         assert(false);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
index af2450f18..13c69180a 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
@@ -144,7 +144,7 @@ void test_throwing_new_during_thread_creation() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_throwing_new_during_thread_creation();
     {
@@ -200,4 +200,6 @@ int main()
         t.join();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
index c24b0413b..26231373f 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
@@ -18,8 +18,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     volatile std::thread t1;
     std::thread t2 ( t1, 1, 2.0 );
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
index 4a2e6f0d4..2a3632cd4 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
@@ -48,7 +48,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         assert(G::n_alive == 0);
@@ -62,4 +62,6 @@ int main()
         assert(G::n_alive == 0);
         assert(G::op_run);
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
index d635470db..135d3ceba 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
@@ -17,8 +17,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread t;
     assert(t.get_id() == std::thread::id());
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
index 7e34729b3..25703b2c3 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
@@ -50,7 +50,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -66,4 +66,6 @@ int main()
         assert(G::op_run);
     }
     assert(G::n_alive == 0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
index 202d61b8f..320b4459b 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
@@ -47,7 +47,7 @@ void f1()
     std::_Exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     {
@@ -60,4 +60,6 @@ int main()
         }
     }
     assert(false);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
index 444760048..fb4b7eb5a 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1;
@@ -25,4 +25,6 @@ int main()
     assert(id1 == id0);
     id1 = std::this_thread::get_id();
     assert(id1 != id0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
index 52d4f2cf3..f95617b4f 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
@@ -17,9 +17,11 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1 = id0;
     assert(id1 == id0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
index a9778f047..32a083ca8 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
@@ -17,8 +17,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id;
     assert(id == std::thread::id());
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
index 7a2fa869d..3858508e1 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
@@ -18,9 +18,11 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::thread::id>();
   }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
index cf89066a5..5c557fddc 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
@@ -18,7 +18,7 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1;
@@ -28,4 +28,6 @@ int main()
     id1 = std::this_thread::get_id();
     assert(!(id1 == id0));
     assert( (id1 != id0));
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
index 69ea217b5..8af73045a 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
@@ -20,7 +20,7 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1;
@@ -39,4 +39,6 @@ int main()
       assert( (id0 >  id2));
       assert( (id0 >= id2));
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
index d07f26b16..a1541c12e 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
@@ -20,9 +20,11 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0 = std::this_thread::get_id();
     std::ostringstream os;
     os << id0;
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
index 325c0bfeb..80bcbf97c 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::thread::id id1;
     std::thread::id id2 = std::this_thread::get_id();
@@ -34,4 +34,6 @@ int main()
     ASSERT_NOEXCEPT(H()(id2));
     H h;
     assert(h(id1) != h(id2));
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
index 8debe7770..bf72e3437 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
@@ -61,7 +61,7 @@ bool G::op_run = false;
 
 void foo() {}
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -86,4 +86,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
index 99cdec913..006bc1e65 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
@@ -41,7 +41,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -54,4 +54,6 @@ int main()
         assert(t1.get_id() == std::thread::id());
         t0.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
index c21de04ea..b64a111c6 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
@@ -46,7 +46,7 @@ bool G::op_run = false;
 
 void foo() {}
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -73,4 +73,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
index 3db473ab1..6f1308cba 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
@@ -41,7 +41,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -50,4 +50,6 @@ int main()
         t0.join();
         assert(!t0.joinable());
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
index 66c810b1b..f43805d7f 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
@@ -41,7 +41,7 @@ public:
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -54,4 +54,6 @@ int main()
         assert(t1.get_id() == id0);
         t1.join();
     }
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
index 3500f2c16..5493f27a4 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
@@ -17,7 +17,9 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::thread::hardware_concurrency() > 0);
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
index 864518dd8..1bf46cdb5 100644
--- a/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
@@ -15,8 +15,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id = std::this_thread::get_id();
     assert(id != std::thread::id());
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
index 59791c84c..7c8552ea8 100644
--- a/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
@@ -16,6 +16,8 @@
 // is therefore non-standard. For this reason the test lives under the 'libcxx'
 // subdirectory.
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
index 5fbaf9d87..c73144db0 100644
--- a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
@@ -18,7 +18,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef Clock::time_point time_point;
@@ -30,4 +30,6 @@ int main()
     std::chrono::nanoseconds err = 5 * ms / 100;
     // The time slept is within 5% of 500ms
     assert(std::abs(ns.count()) < err.count());
+
+  return 0;
 }
diff --git a/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
index 5c1caa0cb..6f772b5c2 100644
--- a/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
@@ -15,7 +15,9 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::this_thread::yield();
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
index 6ea9a8ec8..961eda3ac 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -113,4 +113,6 @@ int main()
              std::scoped_allocator_adaptor<A1<int>>,
              std::scoped_allocator_adaptor<A2<int>>>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
index c14606034..d3734cae1 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<double>> B;
@@ -64,4 +64,6 @@ int main()
         assert(a2 == a1);
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
index 99f0e38fc..427e29957 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<double>> B;
@@ -69,4 +69,6 @@ int main()
         assert(A3<int>::move_called == true);
         assert(a2 == a1);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
index 38878e234..69b767b90 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -64,4 +64,6 @@ int main()
         assert(A3<int>::move_called == false);
         assert(a2 == a1);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
index ac27f8b54..fdf21cec3 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -53,4 +53,6 @@ int main()
         assert(A3<int>::move_called == false);
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
index 7b093826a..6d644db85 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
@@ -21,8 +21,10 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     std::scoped_allocator_adaptor<A1<int>> a;
     a.allocate(10);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
index 057541dd0..05a1649e4 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -44,4 +44,6 @@ int main()
         assert(A1<int>::allocate_called == true);
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
index ffc59b800..7cf3d4109 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
@@ -21,8 +21,10 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     std::scoped_allocator_adaptor<A1<int>> a;
     a.allocate(10, (const void*)0); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
index afe3e40d9..db9338d31 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -65,4 +65,6 @@ int main()
         assert(a.allocate(10, (const void*)20) == (int*)20);
         assert(A2<int>::allocate_called == true);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
index 6e02326fa..97ae33d91 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
@@ -110,7 +110,7 @@ struct F
 
 bool F::constructed = false;
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -184,4 +184,6 @@ int main()
         assert(A3<F>::constructed);
         s->~S();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
index 85fdd38f0..7aa45f05a 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
@@ -135,7 +135,9 @@ void test_with_inner_alloc()
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
index 30fea45b0..d1a03bc05 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
@@ -151,7 +151,9 @@ void test_with_inner_alloc()
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
index c6e13bc18..14f413bd8 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
@@ -152,7 +152,9 @@ void test_with_inner_alloc()
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
index 243b9e997..c26b4652c 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
@@ -151,7 +151,9 @@ void test_with_inner_alloc()
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
index acbe241e7..7a4b14956 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
@@ -143,7 +143,9 @@ void test_with_inner_alloc()
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
index 6a65d2ac6..e93f37f41 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
@@ -125,8 +125,10 @@ void test_bullet_three() {
     POuter.reset();
 }
 
-int main() {
+int main(int, char**) {
     test_bullet_one();
     test_bullet_two();
     test_bullet_three();
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
index e5c17edaf..425f00ad4 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -42,4 +42,6 @@ int main()
         assert((A1<int>::deallocate_called == std::pair<int*, std::size_t>((int*)10, 20)));
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
index 02c7afe4a..50c9d24f0 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
@@ -31,7 +31,7 @@ struct B
 
 bool B::constructed = false;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<B>> A;
@@ -65,4 +65,6 @@ int main()
         assert(A3<S>::destroy_called);
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
index ad0f2e295..7e73939f8 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -40,4 +40,6 @@ int main()
             std::scoped_allocator_adaptor<A2<int>, A3<int>>(A2<int>(6), A3<int>(8))));
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
index 51a9f8117..de9cf4d0c 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -38,4 +38,6 @@ int main()
         assert(a.max_size() == 200);
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
index ccea2b2c0..9a90d17c0 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -39,4 +39,6 @@ int main()
         A a(A1<int>(5), A2<int>(6), A3<int>(8));
         assert(a.outer_allocator() == A1<int>(5));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
index ef4220757..8253fee55 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -50,4 +50,6 @@ int main()
         assert(a2.inner_allocator().inner_allocator().outer_allocator().id() == -1);
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
index 49f242ddf..10475403d 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
@@ -109,7 +109,7 @@ void test_void_pointer()
 
 struct Foo { int x; };
 
-int main()
+int main(int, char**)
 {
     test_pointer<std::scoped_allocator_adaptor<std::allocator<char>>> ();
     test_pointer<std::scoped_allocator_adaptor<std::allocator<int>>> ();
@@ -118,7 +118,9 @@ int main()
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<char>>> ();
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<int>>> ();
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<Foo>>> ();
+
+  return 0;
 }
 #else
-int main() {}
+int main(int, char**) { return 0; }
 #endif
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
index 056189044..2aa7a9891 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::inner_allocator_type,
@@ -33,4 +33,6 @@ int main()
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::inner_allocator_type,
         std::scoped_allocator_adaptor<A2<int>, A3<int>>>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
index a549366c9..628505f65 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
@@ -21,7 +21,7 @@
 #include "allocators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     // sanity checks
     static_assert( (std::is_same<
@@ -68,4 +68,6 @@ int main()
               std::allocator_traits<A2<int>>::is_always_equal::value &&
               std::allocator_traits<A3<int>>::is_always_equal::value)
         ), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
index 6f3605224..fea53af29 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_copy_assignment,
@@ -34,4 +34,6 @@ int main()
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_copy_assignment,
         std::true_type>::value), "");
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
index 5c207c930..d04ea6f1a 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_move_assignment,
@@ -34,4 +34,6 @@ int main()
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_move_assignment,
         std::true_type>::value), "");
 
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
index 5b70dd8fb..fcec67879 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_swap,
@@ -33,4 +33,6 @@ int main()
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_swap,
         std::true_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
index 0f3813e1a..1f871876f 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -68,4 +68,6 @@ int main()
         assert(A3<int>::move_called == false);
         assert(aN == a1);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
index 22987adef..aaf5c1d59 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -58,4 +58,6 @@ int main()
         assert(a2 != a1);
         assert(!(a2 == a1));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
index 0342f614c..c17c6d384 100644
--- a/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -68,4 +68,6 @@ int main()
         assert(A3<int>::move_called == true);
         assert(aN == a1);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/allocator.adaptor/types.pass.cpp b/test/std/utilities/allocator.adaptor/types.pass.cpp
index 00a007f06..7820e29ee 100644
--- a/test/std/utilities/allocator.adaptor/types.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/types.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<
         A1<int>,
@@ -96,4 +96,6 @@ int main()
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::const_void_pointer,
         const void*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
index 0a8c3f781..6cf1efb86 100644
--- a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
@@ -191,7 +191,7 @@ void test_copy_assign_throws()
 #endif
 }
 
-int main() {
+int main(int, char**) {
     test_copy_assign<small1, small2>();
     test_copy_assign<large1, large2>();
     test_copy_assign<small, large>();
@@ -201,4 +201,6 @@ int main() {
     test_copy_assign_self();
     test_copy_assign_throws<small_throws_on_copy>();
     test_copy_assign_throws<large_throws_on_copy>();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.assign/move.pass.cpp b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
index 4baadb2bb..6e1b6d6a6 100644
--- a/test/std/utilities/any/any.class/any.assign/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
@@ -104,7 +104,7 @@ void test_move_assign_noexcept() {
       );
 }
 
-int main() {
+int main(int, char**) {
     test_move_assign_noexcept();
     test_move_assign<small1, small2>();
     test_move_assign<large1, large2>();
@@ -112,4 +112,6 @@ int main() {
     test_move_assign<large, small>();
     test_move_assign_empty<small>();
     test_move_assign_empty<large>();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.assign/value.pass.cpp b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
index 7ccec4b3f..888a6a654 100644
--- a/test/std/utilities/any/any.class/any.assign/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
@@ -202,7 +202,7 @@ void test_sfinae_constraints() {
     }
 }
 
-int main() {
+int main(int, char**) {
     test_assign_value<small1, small2>();
     test_assign_value<large1, large2>();
     test_assign_value<small, large>();
@@ -213,4 +213,6 @@ int main() {
     test_assign_throws<large_throws_on_copy>();
     test_assign_throws<throws_on_move, /* Move = */ true>();
     test_sfinae_constraints();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
index 6c4e9576d..318d9ecab 100644
--- a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
@@ -98,10 +98,12 @@ void test_copy()
     assert(Type::count == 0);
 }
 
-int main() {
+int main(int, char**) {
     test_copy<small>();
     test_copy<large>();
     test_copy_empty();
     test_copy_throws<small_throws_on_copy>();
     test_copy_throws<large_throws_on_copy>();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.cons/default.pass.cpp b/test/std/utilities/any/any.class/any.cons/default.pass.cpp
index 12692a171..6cd7b8937 100644
--- a/test/std/utilities/any/any.class/any.cons/default.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/default.pass.cpp
@@ -20,7 +20,7 @@
 #include "any_helpers.h"
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     {
@@ -43,4 +43,6 @@ int main()
         any const a;
         assertEmpty(a);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
index f696ac5a2..9684fcac7 100644
--- a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
@@ -187,7 +187,7 @@ void test_constructor_explicit() {
     static_assert(std::is_constructible<std::any, IT, std::initializer_list<int>&, int>::value, "");
 }
 
-int main() {
+int main(int, char**) {
     test_in_place_type<small>();
     test_in_place_type<large>();
     test_in_place_type<small_throws_on_copy>();
@@ -198,4 +198,6 @@ int main() {
     test_in_place_type_decayed();
     test_ctor_sfinae();
     test_constructor_explicit();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.cons/move.pass.cpp b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
index 265972a01..e75d56ef2 100644
--- a/test/std/utilities/any/any.class/any.cons/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
@@ -95,7 +95,7 @@ void test_move() {
     assert(Type::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     // noexcept test
     {
@@ -108,4 +108,6 @@ int main()
     test_move<large>();
     test_move_empty();
     test_move_does_not_throw();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.cons/value.pass.cpp b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
index c80a407ff..ed5884975 100644
--- a/test/std/utilities/any/any.class/any.cons/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
@@ -151,11 +151,13 @@ void test_sfinae_constraints() {
     }
 }
 
-int main() {
+int main(int, char**) {
     test_copy_move_value<small>();
     test_copy_move_value<large>();
     test_copy_value_throws<small_throws_on_copy>();
     test_copy_value_throws<large_throws_on_copy>();
     test_move_value_throws();
     test_sfinae_constraints();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
index 3ac003dd0..7cb5d4913 100644
--- a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
@@ -275,7 +275,7 @@ void test_emplace_sfinae_constraints() {
     }
 }
 
-int main() {
+int main(int, char**) {
     test_emplace_type<small>();
     test_emplace_type<large>();
     test_emplace_type<small_throws_on_copy>();
@@ -288,4 +288,6 @@ int main() {
     test_emplace_throws<SmallThrows>();
     test_emplace_throws<LargeThrows>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
index 352b25b80..0a01e8625 100644
--- a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "any_helpers.h"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     using std::any_cast;
@@ -67,4 +67,6 @@ int main()
         assertEmpty<large>(a);
         assert(large::count == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
index f1ff60d47..f4f5ee496 100644
--- a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
@@ -127,7 +127,7 @@ void test_self_swap() {
     assert(large::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_noexcept();
     test_swap_empty<small>();
@@ -137,4 +137,6 @@ int main()
     test_swap<small, large>();
     test_swap<large, small>();
     test_self_swap();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp b/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
index 9b747dca6..54b4153c9 100644
--- a/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "any_helpers.h"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     // noexcept test
@@ -60,4 +60,6 @@ int main()
         a = l;
         assert(a.has_value());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/any.observers/type.pass.cpp b/test/std/utilities/any/any.class/any.observers/type.pass.cpp
index 8d3b40814..bb9089cd8 100644
--- a/test/std/utilities/any/any.class/any.observers/type.pass.cpp
+++ b/test/std/utilities/any/any.class/any.observers/type.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "any_helpers.h"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     {
@@ -37,4 +37,6 @@ int main()
         any const a(l);
         assert(a.type() == typeid(large));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.class/not_literal_type.pass.cpp b/test/std/utilities/any/any.class/not_literal_type.pass.cpp
index b757f7b0b..3a275d51e 100644
--- a/test/std/utilities/any/any.class/not_literal_type.pass.cpp
+++ b/test/std/utilities/any/any.class/not_literal_type.pass.cpp
@@ -15,6 +15,8 @@
 #include <any>
 #include <type_traits>
 
-int main () {
+int main(int, char**) {
     static_assert(!std::is_literal_type<std::any>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
index 8de9164c3..9b9ec4109 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
@@ -166,7 +166,7 @@ void test_cast_function_pointer() {
     assert(fn_ptr == test_fn);
 }
 
-int main() {
+int main(int, char**) {
     test_cast_is_noexcept();
     test_cast_return_type();
     test_cast_nullptr();
@@ -175,4 +175,6 @@ int main() {
     test_cast<large>();
     test_cast_non_copyable_type();
     test_cast_function_pointer();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
index 810c482df..fb69f0d39 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
@@ -309,7 +309,7 @@ void test_cast_to_value() {
     assert(Type::count == 0);
 }
 
-int main() {
+int main(int, char**) {
     test_cast_is_not_noexcept();
     test_cast_return_type();
     test_cast_empty();
@@ -317,4 +317,6 @@ int main() {
     test_cast_to_reference<large>();
     test_cast_to_value<small>();
     test_cast_to_value<large>();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
index cd69a3d85..396d994d2 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
@@ -61,9 +61,11 @@ void test_rvalue_any_cast_request_lvalue()
     any_cast<int&>(42);
 }
 
-int main()
+int main(int, char**)
 {
     test_const_lvalue_cast_request_non_const_lvalue();
     test_lvalue_any_cast_request_rvalue();
     test_rvalue_any_cast_request_lvalue();
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
index c0c6e03fd..8669de4fd 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
@@ -24,7 +24,7 @@ struct TestType2 {};
 // is triggered by these tests.
 // expected-error@const_correctness.fail.cpp:* 0+ {{call to unavailable function 'any_cast': introduced in macOS 10.14}}
 
-int main()
+int main(int, char**)
 {
     using std::any;
     using std::any_cast;
@@ -46,4 +46,6 @@ int main()
     // expected-error@any:* {{cannot cast from lvalue of type 'const TestType2' to rvalue reference type 'TestType2 &&'; types are not compatible}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &&>(static_cast<any const&&>(a)); // expected-note {{requested here}}
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
index c90df2ebd..97f1d9795 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
@@ -43,7 +43,7 @@ struct no_move {
 // is triggered by these tests.
 // expected-error@not_copy_constructible.fail.cpp:* 0+ {{call to unavailable function 'any_cast': introduced in macOS 10.14}}
 
-int main() {
+int main(int, char**) {
     any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{static_cast from 'no_copy' to 'no_copy' uses deleted function}}
@@ -58,4 +58,6 @@ int main() {
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{static_cast from 'typename remove_reference<no_move &>::type' (aka 'no_move') to 'no_move' uses deleted function}}
     any_cast<no_move>(static_cast<any &&>(a));
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
index 194535824..1ce06e289 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
@@ -21,7 +21,7 @@
 using std::any;
 using std::any_cast;
 
-int main()
+int main(int, char**)
 {
     any a(1);
 
@@ -50,4 +50,6 @@ int main()
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int const &&>(&a2); // expected-note {{requested here}}
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
index e185f239f..1e9708545 100644
--- a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
@@ -131,7 +131,7 @@ void test_make_any_throws()
 
 #endif
 
-int main() {
+int main(int, char**) {
     test_make_any_type<small>();
     test_make_any_type<large>();
     test_make_any_type<small_throws_on_copy>();
@@ -144,4 +144,6 @@ int main() {
     test_make_any_throws<LargeThrows>();
 
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/any/any.nonmembers/swap.pass.cpp b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
index 3e5a91d0d..cff34964a 100644
--- a/test/std/utilities/any/any.nonmembers/swap.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
@@ -28,7 +28,7 @@
 using std::any;
 using std::any_cast;
 
-int main()
+int main(int, char**)
 {
 
     { // test noexcept
@@ -44,4 +44,6 @@ int main()
         assert(any_cast<int>(a1) == 2);
         assert(any_cast<int>(a2) == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp b/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
index 35ddfa32e..2e744cc81 100644
--- a/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
+++ b/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
@@ -18,7 +18,7 @@
 
 #include <charconv>
 
-int main()
+int main(int, char**)
 {
     using std::from_chars;
     char buf[] = "01001";
@@ -26,4 +26,6 @@ int main()
 
     from_chars(buf, buf + sizeof(buf), lv);      // expected-error {{call to deleted function}}
     from_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
+
+  return 0;
 }
diff --git a/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp b/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
index 9f05250d3..d750cb4a8 100644
--- a/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
+++ b/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
@@ -183,8 +183,10 @@ struct test_signed : roundtrip_test_base<T>
     }
 };
 
-int main()
+int main(int, char**)
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
+
+  return 0;
 }
diff --git a/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp b/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
index 36c7d3cca..5c947d122 100644
--- a/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
+++ b/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
@@ -18,7 +18,7 @@
 
 #include <charconv>
 
-int main()
+int main(int, char**)
 {
     using std::to_chars;
     char buf[10];
@@ -26,4 +26,6 @@ int main()
 
     to_chars(buf, buf + sizeof(buf), false);   // expected-error {{call to deleted function}}
     to_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
+
+  return 0;
 }
diff --git a/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp b/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
index 18ddf203b..c034151de 100644
--- a/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
+++ b/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
@@ -81,8 +81,10 @@ struct test_signed : to_chars_test_base<T>
     }
 };
 
-int main()
+int main(int, char**)
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
index c191b191b..1dbbd8533 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::divides<int> F;
     const F f = F();
@@ -37,4 +37,6 @@ int main()
     constexpr double bar = std::divides<> () (3.0, 2);
     static_assert ( bar == 1.5, "" ); // exact in binary
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
index 54ab577ea..186695f7b 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::minus<int> F;
     const F f = F();
@@ -37,4 +37,6 @@ int main()
     constexpr double bar = std::minus<> () (3.0, 2);
     static_assert ( bar == 1.0, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
index f426c57cf..3679a2d32 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::modulus<int> F;
     const F f = F();
@@ -37,4 +37,6 @@ int main()
     constexpr int bar = std::modulus<> () (3L, 2);
     static_assert ( bar == 1, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
index 5ef4791b5..a09e59c78 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::multiplies<int> F;
     const F f = F();
@@ -37,4 +37,6 @@ int main()
     constexpr double bar = std::multiplies<> () (3.0, 2);
     static_assert ( bar == 6.0, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
index d7346c769..553bf83e2 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::negate<int> F;
     const F f = F();
@@ -36,4 +36,6 @@ int main()
     constexpr double bar = std::negate<> () (3.0);
     static_assert ( bar == -3.0, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
index 6bca266e0..b2614f430 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::plus<int> F;
     const F f = F();
@@ -37,4 +37,6 @@ int main()
     constexpr double bar = std::plus<> () (3.0, 2);
     static_assert ( bar == 5.0, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
index ca57c223a..154a0f887 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
@@ -22,7 +22,7 @@ public:
 };
 
 
-int main ()
+int main(int, char**)
 {
     static_assert ( !is_transparent<std::plus<int>>::value, "" );
     static_assert ( !is_transparent<std::plus<std::string>>::value, "" );
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
index 4c025d141..931778f54 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
@@ -28,7 +28,9 @@ struct Fun
   }
 };
 
-int main()
+int main(int, char**)
 {
     std::bind(Fun{}, std::placeholders::_1, 42)("hello");
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
index fc089e165..7010b33f3 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
@@ -115,7 +115,7 @@ void do_test_r(Fn* func) {
     }
 }
 
-int main()
+int main(int, char**)
 {
     do_test<int>(return_value);
     do_test<int&>(return_lvalue);
@@ -129,4 +129,6 @@ int main()
     do_test_r<long>(return_rvalue);
     do_test_r<long>(return_const_rvalue);
 
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
index ccc6c27e7..8beeb3321 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
@@ -26,11 +26,13 @@ float _pow(float a, float b)
     return std::pow(a, b);
 }
 
-int main()
+int main(int, char**)
 {
     std::function<float(float, float)> fnc = _pow;
     auto task = std::bind(fnc, 2.f, 4.f);
     auto task2(task);
     assert(task() == 16);
     assert(task2() == 16);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
index b386b99a9..b87918da1 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
@@ -38,7 +38,7 @@ struct BadUnaryFunction
     }
 };
 
-int main()
+int main(int, char**)
 {
     // Check that BadUnaryFunction::operator()(S const &) is not
     // instantiated when checking if BadUnaryFunction is a nested bind
@@ -47,4 +47,6 @@ int main()
     b(0);
     auto b2 = std::bind<long>(DummyUnaryFunction(), BadUnaryFunction());
     b2(0);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
index 8d6bc70e7..a77e1895d 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
@@ -40,7 +40,7 @@ struct A_int_0
     int operator()() const {return 5;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::bind(f), 1);
     test(std::bind(&f), 1);
@@ -51,4 +51,6 @@ int main()
     test(std::bind<int>(&f), 1);
     test(std::bind<int>(A_int_0()), 4);
     test_const(std::bind<int>(A_int_0()), 5);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
index 92f65af2c..9b81d3301 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
@@ -280,10 +280,12 @@ test3()
     assert(b);
 }
 
-int main()
+int main(int, char**)
 {
     test_void_1();
     test_int_1();
     test_void_2();
     test3();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
index b7facb38a..10d2ce017 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
@@ -258,10 +258,12 @@ void test_nested()
     assert(std::bind(f_nested, std::bind(g_nested, _1))(3) == 31);
 }
 
-int main()
+int main(int, char**)
 {
     test_void_1();
     test_int_1();
     test_void_2();
     test_nested();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
index cc982d1b8..2c8e56f03 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
@@ -54,7 +54,7 @@ struct A_int_0
     int operator()() const {count += 2; return 5;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::bind(f));
     test(std::bind(&f));
@@ -70,4 +70,6 @@ int main()
     test(std::bind<void>(&g));
     test(std::bind<void>(A_int_0()));
     test_const(std::bind<void>(A_int_0()));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
index c4d82948e..0d5be3413 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
@@ -41,11 +41,13 @@ struct plus_one
   }
 };
 
-int main()
+int main(int, char**)
 {
     using std::placeholders::_1;
 
     auto g = std::bind(power(), 2, _1);
     assert(g(5) == 32);
     assert(std::bind(plus_one(), g)(5) == 33);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
index cf065e4e3..8314dbe1e 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
@@ -27,11 +27,13 @@ test(const T&)
 
 struct C {};
 
-int main()
+int main(int, char**)
 {
     test<true>(std::bind(C()));
     test<true>(std::bind(C(), std::placeholders::_2));
     test<true>(std::bind<int>(C()));
     test<false>(1);
     test<false>(std::placeholders::_2);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
index da7880fb2..c1af159b2 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
@@ -24,7 +24,7 @@ void test() {
 
 struct C {};
 
-int main() {
+int main(int, char**) {
     test<int>();
     test<void>();
     test<C>();
@@ -35,4 +35,6 @@ int main() {
     test<int(*)()>();
     test<int (C::*)()>();
     test<decltype(std::placeholders::_2)>();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
index ecaa45bba..d2ccf1faf 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
@@ -25,7 +25,7 @@ test(const T&)
 
 struct C {};
 
-int main()
+int main(int, char**)
 {
     test<1>(std::placeholders::_1);
     test<2>(std::placeholders::_2);
@@ -41,4 +41,6 @@ int main()
     test<0>(5.5);
     test<0>('a');
     test<0>(C());
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
index 8e4ec60ef..b71aae818 100644
--- a/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
@@ -80,7 +80,7 @@ void use_placeholders_to_prevent_unused_warning() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     use_placeholders_to_prevent_unused_warning();
     test(std::placeholders::_1);
@@ -93,4 +93,6 @@ int main()
     test(std::placeholders::_8);
     test(std::placeholders::_9);
     test(std::placeholders::_10);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
index 664e3f25d..aa5324621 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::bit_and<int> F;
     const F f = F();
@@ -57,4 +57,6 @@ int main()
     constexpr int bar = std::bit_and<> () (0x58D3L, 0xEA95);
     static_assert ( bar == 0x4891, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
index e18139bc6..8bfa48f3e 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::bit_not<int> F;
     const F f = F();
@@ -42,4 +42,6 @@ int main()
 
     constexpr int bar = std::bit_not<> () (0xEA95) & 0xFFFF;
     static_assert ( bar == 0x156A, "" );
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
index 19bd1a731..8abcd63af 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::bit_or<int> F;
     const F f = F();
@@ -57,4 +57,6 @@ int main()
     constexpr int bar = std::bit_or<> () (0x58D3L, 0xEA95);
     static_assert ( bar == 0xFAD7, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
index 757417a2c..070bd4c5f 100644
--- a/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::bit_xor<int> F;
@@ -61,4 +61,6 @@ int main()
     static_assert ( bar == 0xB246, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
index c360a51b4..5ad0f233f 100644
--- a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
@@ -22,7 +22,7 @@ public:
 };
 
 
-int main () {
+int main(int, char**) {
     static_assert ( !is_transparent<std::bit_and<int>>::value, "" );
     static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" );
     static_assert (  is_transparent<std::bit_and<void>>::value, "" );
diff --git a/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp b/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
index 7632dc580..a0c41432e 100644
--- a/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
@@ -42,6 +42,8 @@ static_assert(test_constexpr_context<int>(), "");
 static_assert(test_constexpr_context<void>(), "");
 
 
-int main() {
+int main(int, char**) {
 
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp b/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
index 7ec8f6632..beed574f8 100644
--- a/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::equal_to<int> F;
     const F f = F();
@@ -39,4 +39,6 @@ int main()
     constexpr bool bar = std::equal_to<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/comparisons/greater.pass.cpp b/test/std/utilities/function.objects/comparisons/greater.pass.cpp
index 12111ef28..35c05757c 100644
--- a/test/std/utilities/function.objects/comparisons/greater.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/greater.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::greater<int> F;
     const F f = F();
@@ -49,4 +49,6 @@ int main()
     constexpr bool bar = std::greater<> () (36.0, 36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp b/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
index 1ac67eadc..9a6d36c41 100644
--- a/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::greater_equal<int> F;
     const F f = F();
@@ -49,4 +49,6 @@ int main()
     constexpr bool bar = std::greater_equal<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/comparisons/less.pass.cpp b/test/std/utilities/function.objects/comparisons/less.pass.cpp
index abfe09ad5..31a2f975b 100644
--- a/test/std/utilities/function.objects/comparisons/less.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/less.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::less<int> F;
     const F f = F();
@@ -48,4 +48,6 @@ int main()
     constexpr bool bar = std::less<> () (36.0, 36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp b/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
index 2e7330424..31cbed171 100644
--- a/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::less_equal<int> F;
     const F f = F();
@@ -49,4 +49,6 @@ int main()
     constexpr bool bar = std::less_equal<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp b/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
index fd3291570..0e405de1b 100644
--- a/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::not_equal_to<int> F;
     const F f = F();
@@ -41,4 +41,6 @@ int main()
     constexpr bool bar = std::not_equal_to<> () (36.0, 36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
index f3896770e..4be81925b 100644
--- a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
@@ -22,7 +22,7 @@ public:
 };
 
 
-int main ()
+int main(int, char**)
 {
     static_assert ( !is_transparent<std::less<int>>::value, "" );
     static_assert ( !is_transparent<std::less<std::string>>::value, "" );
diff --git a/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
index b0a41447e..57350f16c 100644
--- a/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
+++ b/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
@@ -340,9 +340,11 @@ void noexcept_test() {
     }
 }
 
-int main() {
+int main(int, char**) {
     bullet_one_two_tests();
     bullet_three_four_tests();
     bullet_five_tests();
     noexcept_test();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
index f7f63a0bd..b0404659d 100644
--- a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
+++ b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
@@ -31,8 +31,10 @@
 
 int foo(int) { return 42; }
 
-int main() {
+int main(int, char**) {
 #if defined(__cpp_lib_invoke)
   assert(std::invoke(foo, 101) == 42);
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp b/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
index 483f7a327..130644fbd 100644
--- a/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
@@ -35,7 +35,9 @@ test(F f)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test(std::mem_fn(&A::data_));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
index 75211ba21..52581881a 100644
--- a/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
@@ -36,7 +36,9 @@ test(F f)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test(std::mem_fn(&A::data_));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
index a04e49efa..a271c0670 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
@@ -65,7 +65,7 @@ test2(F f)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
@@ -73,4 +73,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((noexcept(std::mem_fn(&A::test0))), ""); // LWG#2489
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
index 9ea6531a2..dc93196cd 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
@@ -69,9 +69,11 @@ test2(F f)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
index 9258c0a03..594e1de8a 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
@@ -69,9 +69,11 @@ test2(F f)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
index c22baecd9..04439387d 100644
--- a/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
+++ b/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
@@ -69,9 +69,11 @@ test2(F f)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
index c3adbf7ff..a1c778412 100644
--- a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
+++ b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
@@ -602,7 +602,7 @@ void test_lwg2767() {
     }
 }
 
-int main()
+int main(int, char**)
 {
     constructor_tests();
     return_type_tests();
@@ -612,4 +612,6 @@ int main()
     call_operator_forwarding_test();
     call_operator_noexcept_test();
     test_lwg2767();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
index 2bb9cb583..00b7d53be 100644
--- a/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
@@ -12,4 +12,6 @@
 // since they require calling the implementation specific "__invoke" and
 // "__invoke_constexpr" functions.
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
index 76ba44fc9..79a4855ea 100644
--- a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
@@ -15,10 +15,12 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::binary_function<int, short, bool> bf;
     static_assert((std::is_same<bf::first_argument_type, int>::value), "");
     static_assert((std::is_same<bf::second_argument_type, short>::value), "");
     static_assert((std::is_same<bf::result_type, bool>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
index 0d178b0dc..f68b4b37c 100644
--- a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
@@ -15,9 +15,11 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::unary_function<int, bool> uf;
     static_assert((std::is_same<uf::argument_type, int>::value), "");
     static_assert((std::is_same<uf::result_type, bool>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
index 3293a3215..55cde8fe7 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
@@ -122,7 +122,9 @@ test2()
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
index d0ce11b08..106b0d37f 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
@@ -118,7 +118,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
index 59178deb6..be4db4e5a 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
@@ -136,7 +136,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
index 7f3e837a7..3656caa87 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
@@ -127,7 +127,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
index 04adb178b..0b345deed 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
@@ -122,7 +122,9 @@ test2()
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
index dca691175..4106c5d6a 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
@@ -117,7 +117,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
index 6a5c215a7..757bcc757 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
@@ -130,7 +130,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
index 27c3d0c82..3a20b8851 100644
--- a/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
@@ -124,7 +124,9 @@ test2()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
index 098b8ac11..eaf5eeb82 100644
--- a/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
@@ -82,7 +82,7 @@ test()
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -92,4 +92,6 @@ int main() {
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp b/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
index 4b0f016d7..773336f66 100644
--- a/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
@@ -89,7 +89,7 @@ test()
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -99,4 +99,6 @@ int main() {
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
index 02fe32ece..779762e7e 100644
--- a/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
index 2ec1d53c5..eb223b88e 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
@@ -19,7 +19,9 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_function_call>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
index 6b6ee8a64..385919227 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
@@ -13,7 +13,9 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::bad_function_call ex;
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
index 50fb4f19d..2a34eff92 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
@@ -18,7 +18,9 @@
 
 struct S : public std::function<void()> { using function::function; };
 
-int main() {
+int main(int, char**) {
    S f1( [](){} );
    S f2(std::allocator_arg, std::allocator<int>{}, f1);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
index 8c50c284b..70f68d2f4 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
@@ -20,10 +20,12 @@
 using Fn = std::function<void()>;
 struct S : public std::function<void()> { using function::function; };
 
-int main() {
+int main(int, char**) {
     S s( [](){} );
     S f1( s );
 #if TEST_STD_VER <= 14
     S f2(std::allocator_arg, std::allocator<int>{}, s);
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
index b6dbcab53..ec25bdf78 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
@@ -57,7 +57,7 @@ int A::count = 0;
 int g(int) {return 0;}
 int h(int) {return 1;}
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -132,4 +132,6 @@ int main()
     }
     assert(A::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
index 1b55baa02..ab5eef372 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
@@ -17,7 +17,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f;
@@ -25,4 +25,6 @@ int main()
     f = g;
     assert(f);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
index c32baebb5..fe5d24806 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
@@ -60,7 +60,7 @@ struct LValueCallable {
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -111,4 +111,6 @@ int main()
         static_assert(!std::is_constructible<Fn, RValueCallable>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
index abff663cb..f70a2087c 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
@@ -63,7 +63,7 @@ struct LValueCallable {
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -115,4 +115,6 @@ int main()
         static_assert(!std::is_assignable<Fn&, RValueCallable>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
index 159848666..21c2f216e 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
@@ -58,6 +58,8 @@ void test_pr34298()
   }
 }
 
-int main() {
+int main(int, char**) {
   test_pr34298();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
index 89b787623..ebea3d0aa 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
@@ -239,8 +239,10 @@ void test_md() {
     test_imp<int MemData::*, int(MemData&)>();
 }
 
-int main() {
+int main(int, char**) {
     test_func();
     test_mf();
     test_md();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
index acbeb9f9c..50a11fb81 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
@@ -18,7 +18,9 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(std::allocator_arg, std::allocator<int>());
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
index b048109e5..3b37ce6ff 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
@@ -20,10 +20,12 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f(std::allocator_arg, bare_allocator<int>());
     assert(!f);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
index bddc92787..c31c0a21f 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
@@ -22,7 +22,9 @@
 
 void foo(int) {}
 
-int main()
+int main(int, char**)
 {
     std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
index 4d49434f3..6fa0d6fae 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
@@ -106,7 +106,7 @@ void test_for_alloc(Alloc& alloc) {
     test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
 }
 
-int main()
+int main(int, char**)
 {
     {
         bare_allocator<DummyClass> bare_alloc;
@@ -126,4 +126,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
index b6703c0b7..621588f81 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
@@ -21,9 +21,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::function<void(int)> F;
     F f1;
     F f2(std::allocator_arg, std::allocator<int>(), f1);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
index 39050e6f1..583ca162e 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
@@ -111,7 +111,7 @@ void test_for_alloc(Alloc& alloc)
     test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
 }
 
-int main()
+int main(int, char**)
 {
   {
     bare_allocator<DummyClass> alloc;
@@ -121,4 +121,6 @@ int main()
     non_default_test_allocator<DummyClass> alloc(42);
     test_for_alloc(alloc);
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
index 32d19ebf7..52bc528fe 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
@@ -20,7 +20,9 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(std::allocator_arg, std::allocator<int>(), nullptr);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
index 6378a6cd9..653057f6e 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
@@ -20,8 +20,10 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(std::allocator_arg, bare_allocator<int>(), nullptr);
     assert(!f);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
index 558b7814c..643cad8f0 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
@@ -50,10 +50,12 @@ int A::count = 0;
 
 int g(int) { return 0; }
 
-int main()
+int main(int, char**)
 {
     {
         std::function<int(int)> f = A();
         std::function<int(int)> f2(std::allocator_arg, std::allocator<A>(), std::move(f));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
index 8f379e303..064046d0b 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
@@ -54,7 +54,7 @@ int A::count = 0;
 
 int g(int) { return 0; }
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -105,4 +105,6 @@ int main()
         assert(f2.target<Ptr>());
         assert(f.target<Ptr>()); // f is unchanged because the target is small
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
index df2a43aba..d7b11ae1b 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
@@ -48,7 +48,7 @@ int g(int) { return 0; }
 int g2(int, int) { return 2; }
 int g3(int, int, int) { return 3; }
 
-int main() {
+int main(int, char**) {
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f = A();
@@ -134,4 +134,6 @@ int main() {
     assert(f.target<int (*)(int)>() == 0);
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
index 9f03ee7a1..dbbde5ce4 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
@@ -50,7 +50,7 @@ int A::count = 0;
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -161,4 +161,6 @@ int main()
         LIBCPP_ASSERT(f.target<Ptr>()); // f is unchanged because the target is small
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
index 06ea4e058..46c14ce36 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
@@ -15,8 +15,10 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f;
     assert(!f);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
index 026cfc2d4..e15fbbaae 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
@@ -33,7 +33,7 @@ struct A
 std::function<void()> A::global;
 bool A::cancel = false;
 
-int main()
+int main(int, char**)
 {
   A::global = A();
   assert(A::global.target<A>());
@@ -42,4 +42,6 @@ int main()
   A::cancel = true;
   A::global = std::function<void()>(nullptr);
   assert(!A::global.target<A>());
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
index b685d53bf..d58e191c4 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
@@ -15,8 +15,10 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(nullptr);
     assert(!f);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
index 7a8d3e380..ff81080ff 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
@@ -46,7 +46,7 @@ int A::count = 0;
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -68,4 +68,6 @@ int main()
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
index c4006a7c9..def86085d 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
@@ -33,7 +33,7 @@ struct A
 std::function<void()> A::global;
 bool A::cancel = false;
 
-int main()
+int main(int, char**)
 {
   A::global = A();
   assert(A::global.target<A>());
@@ -42,4 +42,6 @@ int main()
   A::cancel = true;
   A::global = nullptr;
   assert(!A::global.target<A>());
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
index 5f91e5c87..0f8e051d4 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
@@ -39,7 +39,9 @@ test_int_1()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_int_1();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
index 7775cad67..fb67a3abf 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
@@ -401,7 +401,7 @@ void test_int_2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_void_0();
     test_int_0();
@@ -409,4 +409,6 @@ int main()
     test_int_1();
     test_void_2();
     test_int_2();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
index 5a6f503a2..8ddd1cd2b 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
@@ -48,7 +48,7 @@ public:
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     {
@@ -60,4 +60,6 @@ int main()
     }
     assert(A::count == 0);
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
index a75aee330..93997a0b5 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
@@ -57,7 +57,7 @@ int h(int) { return 1; }
 int g2(int, int) { return 2; }
 int g3(int, int, int) { return 3; }
 
-int main() {
+int main(int, char**) {
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f1 = A(1);
@@ -189,4 +189,6 @@ int main() {
   }
   assert(globalMemCounter.checkOutstandingNewEq(0));
   assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
index c68a1ca82..698a461c8 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
@@ -27,7 +27,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f;
@@ -37,4 +37,6 @@ int main()
     assert(f != nullptr);
     assert(nullptr != f);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
index 7b59b56d0..d5031ba06 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
@@ -55,7 +55,7 @@ int A::count = 0;
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f = A();
@@ -89,4 +89,6 @@ int main()
     assert(f.target<int>() == nullptr);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
index 52d07a45a..d9c8fc48d 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
@@ -47,7 +47,7 @@ int A::count = 0;
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f = A();
@@ -57,4 +57,6 @@ int main()
     std::function<int(int)> f;
     assert(f.target_type() == typeid(void));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
index 496dee8ae..8083ad83a 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
@@ -98,10 +98,12 @@ void test_other_function ()
     static_assert((!has_second_argument_type<F>::value), "" );
 }
 
-int main()
+int main(int, char**)
 {
     test_nullary_function<std::function<int()>, int>();
     test_unary_function  <std::function<double(int)>, double, int>();
     test_binary_function <std::function<double(int, char)>, double, int, char>();
     test_other_function  <std::function<double(int, char, double)>, double>();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp b/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
index 1b0a1c63f..29767a58c 100644
--- a/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_and<int> F;
     const F f = F();
@@ -48,4 +48,6 @@ int main()
     constexpr bool bar = std::logical_and<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
index 2c0c9f3bc..e93fd06fd 100644
--- a/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_not<int> F;
     const F f = F();
@@ -38,4 +38,6 @@ int main()
     constexpr bool bar = std::logical_not<> () (36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp b/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
index 497a9d981..abe536572 100644
--- a/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_or<int> F;
     const F f = F();
@@ -47,4 +47,6 @@ int main()
     constexpr bool bar = std::logical_or<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
index 3aa24c443..eb590b31a 100644
--- a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
@@ -22,7 +22,7 @@ public:
 };
 
 
-int main ()
+int main(int, char**)
 {
     static_assert ( !is_transparent<std::logical_and<int>>::value, "" );
     static_assert ( !is_transparent<std::logical_and<std::string>>::value, "" );
diff --git a/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
index ca8b76711..713afc665 100644
--- a/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
@@ -28,7 +28,9 @@ struct Predicate {
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::binary_negate<Predicate> f((Predicate())); // expected-error{{'binary_negate<Predicate>' is deprecated}}
     (void)f;
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/negators/binary_negate.pass.cpp b/test/std/utilities/function.objects/negators/binary_negate.pass.cpp
index 1e7edcb32..41541c10f 100644
--- a/test/std/utilities/function.objects/negators/binary_negate.pass.cpp
+++ b/test/std/utilities/function.objects/negators/binary_negate.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::binary_negate<std::logical_and<int> > F;
     const F f = F(std::logical_and<int>());
@@ -25,4 +25,6 @@ int main()
     assert( f(36, 0));
     assert( f(0, 36));
     assert( f(0, 0));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
index 9fbe6db66..407cbd4fc 100644
--- a/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
@@ -27,6 +27,8 @@ struct Predicate {
     bool operator()(argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::not1(Predicate()); // expected-error{{'not1<Predicate>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/negators/not1.pass.cpp b/test/std/utilities/function.objects/negators/not1.pass.cpp
index 33268222b..07c160a97 100644
--- a/test/std/utilities/function.objects/negators/not1.pass.cpp
+++ b/test/std/utilities/function.objects/negators/not1.pass.cpp
@@ -13,9 +13,11 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_not<int> F;
     assert(std::not1(F())(36));
     assert(!std::not1(F())(0));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
index 032ce3429..24178e0a0 100644
--- a/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
@@ -28,6 +28,8 @@ struct Predicate {
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::not2(Predicate()); // expected-error{{'not2<Predicate>' is deprecated}}
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/negators/not2.pass.cpp b/test/std/utilities/function.objects/negators/not2.pass.cpp
index 208d33b4a..d9f3c95fd 100644
--- a/test/std/utilities/function.objects/negators/not2.pass.cpp
+++ b/test/std/utilities/function.objects/negators/not2.pass.cpp
@@ -13,11 +13,13 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_and<int> F;
     assert(!std::not2(F())(36, 36));
     assert( std::not2(F())(36, 0));
     assert( std::not2(F())(0, 36));
     assert( std::not2(F())(0, 0));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp b/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
index 99cdf136d..15a0a2778 100644
--- a/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
+++ b/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
@@ -27,7 +27,9 @@ struct Predicate {
     bool operator()(argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::unary_negate<Predicate> f((Predicate())); // expected-error{{'unary_negate<Predicate>' is deprecated}}
     (void)f;
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/negators/unary_negate.pass.cpp b/test/std/utilities/function.objects/negators/unary_negate.pass.cpp
index ec00c3e32..54fd54f39 100644
--- a/test/std/utilities/function.objects/negators/unary_negate.pass.cpp
+++ b/test/std/utilities/function.objects/negators/unary_negate.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::unary_negate<std::logical_not<int> > F;
     const F f = F(std::logical_not<int>());
@@ -22,4 +22,6 @@ int main()
     static_assert((std::is_same<F::result_type, bool>::value), "" );
     assert(f(36));
     assert(!f(0));
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
index 5e67db520..c15989f00 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
@@ -30,7 +30,7 @@ test(T& t)
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -41,4 +41,6 @@ int main()
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
index 16ce96112..3ef0cdda8 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
@@ -42,7 +42,7 @@ test_function()
     assert(&r2.get() == &f);
 }
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -53,4 +53,6 @@ int main()
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
index 64726b53e..355047d98 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
@@ -30,7 +30,7 @@ test(T& t)
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -41,4 +41,6 @@ int main()
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
index f7a6670b4..f02a9974d 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
@@ -17,7 +17,9 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::reference_wrapper<const int> r(3);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
index 2cbb1a010..a43d0fd25 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
@@ -29,7 +29,7 @@ test(T& t)
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -40,4 +40,6 @@ int main()
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
index b16a4b476..d4cb421f5 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
@@ -15,9 +15,11 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::reference_wrapper<const int> r = std::cref(i);
     assert(&r.get() == &i);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
index 3023f8da2..093b7e230 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
@@ -15,10 +15,12 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const int i = 0;
     std::reference_wrapper<const int> r1 = std::cref(i);
     std::reference_wrapper<const int> r2 = std::cref(r1);
     assert(&r2.get() == &i);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
index 9e283d1bf..c07028d21 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
@@ -22,7 +22,9 @@ struct A {};
 
 const A source() {return A();}
 
-int main()
+int main(int, char**)
 {
     std::reference_wrapper<const A> r = std::ref(source());
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
index a8af5aa4c..f64d8ad8c 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
@@ -15,9 +15,11 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::reference_wrapper<int> r = std::ref(i);
     assert(&r.get() == &i);
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
index fee5009a7..4fdaf992c 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
@@ -22,7 +22,7 @@ bool is5 ( int i ) { return i == 5; }
 template <typename T>
 bool call_pred ( T pred ) { return pred(5); }
 
-int main()
+int main(int, char**)
 {
     {
     int i = 0;
@@ -39,4 +39,6 @@ int main()
     assert(call_pred(std::ref(cp)));
     assert(cp.count() == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
index 6302c51b8..d54d5184c 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
@@ -45,7 +45,9 @@ test_int_1()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_int_1();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
index 425bc6df0..fd3104133 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
@@ -319,10 +319,12 @@ testint_2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_void_1();
     test_int_1();
     test_void_2();
     testint_2();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
index 37d7cfca9..67cf51f33 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
@@ -69,7 +69,9 @@ struct A_void_1
     }
 };
 
-int main()
+int main(int, char**)
 {
     test_int_0();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
index 735bfd890..18e655313 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
@@ -61,7 +61,9 @@ test_void_0()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_void_0();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/type.pass.cpp b/test/std/utilities/function.objects/refwrap/type.pass.cpp
index ef46e15d0..d17ab8100 100644
--- a/test/std/utilities/function.objects/refwrap/type.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/type.pass.cpp
@@ -17,7 +17,7 @@
 
 class C {};
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::reference_wrapper<C>::type,
                                                        C>::value), "");
@@ -33,4 +33,6 @@ int main()
                                                        int*(C::*)(double*)>::value), "");
     static_assert((std::is_same<std::reference_wrapper<int (C::*)(double*) const volatile>::type,
                                                        int (C::*)(double*) const volatile>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
index 14a06a9c3..17eef26f0 100644
--- a/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
@@ -52,7 +52,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<double>();
@@ -60,4 +60,6 @@ int main()
 #if TEST_STD_VER >= 11
     test<MoveOnly>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp b/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
index 9aaa28279..198789839 100644
--- a/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
@@ -28,7 +28,7 @@ void check() {
 
 struct T { };
 
-int main() {
+int main(int, char**) {
   check<T,             T>();
   check<T&,            T>();
   check<T const,       T>();
@@ -54,4 +54,6 @@ int main() {
   check<std::reference_wrapper<T[3]>&,     T (&)[3]>();
   check<std::reference_wrapper<T ()>,      T (&)()>();
   check<std::reference_wrapper<T ()>&,     T (&)()>();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp b/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
index f6d48a51e..209d5e2a0 100644
--- a/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
@@ -39,7 +39,7 @@ void check() {
 
 struct T { };
 
-int main() {
+int main(int, char**) {
   check<T>();
   check<int>();
   check<float>();
@@ -47,4 +47,6 @@ int main() {
   check<T*>();
   check<int*>();
   check<float*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
index 50cda1169..5a6a41fdb 100644
--- a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
@@ -68,7 +68,7 @@ public:
     static const bool value = sizeof(test<T>(0)) == 1;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::reference_wrapper<functor1>::result_type,
                                 char>::value), "");
@@ -93,4 +93,6 @@ int main()
     static_assert(has_result_type<std::reference_wrapper<functor3> >::value, "");
     static_assert(!has_result_type<std::reference_wrapper<functor4> >::value, "");
     static_assert(!has_result_type<std::reference_wrapper<C> >::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp b/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
index 90ab8e1bb..8f6c3e14e 100644
--- a/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/unord.hash/enum.fail.cpp b/test/std/utilities/function.objects/unord.hash/enum.fail.cpp
index b824b51ea..2e36b4c55 100644
--- a/test/std/utilities/function.objects/unord.hash/enum.fail.cpp
+++ b/test/std/utilities/function.objects/unord.hash/enum.fail.cpp
@@ -16,8 +16,10 @@
 
 struct X {};
 
-int main()
+int main(int, char**)
 {
     X x;
     size_t h = std::hash<X>{} ( x );
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
index 96c667feb..e172bc2f3 100644
--- a/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
@@ -49,7 +49,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<Cardinals>();
 
@@ -59,4 +59,6 @@ int main()
     test<EightBitColors>();
 
     test<Fruits>();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/unord.hash/floating.pass.cpp b/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
index 1ab164341..31b1b2d07 100644
--- a/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/floating.pass.cpp
@@ -64,9 +64,11 @@ test()
     assert(pinf != ninf);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
index 761c76dc1..dbd44a882 100644
--- a/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
@@ -46,7 +46,7 @@ test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -108,4 +108,6 @@ int main()
     test<__int128_t>();
     test<__uint128_t>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
index 6efcebc4e..c47f8fa76 100644
--- a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
@@ -22,7 +22,7 @@
 
 struct X {};
 
-int main()
+int main(int, char**)
 {
     using H = std::hash<X>;
     static_assert(!std::is_default_constructible<H>::value, "");
@@ -34,4 +34,6 @@ int main()
     static_assert(!std::is_invocable<H, X&>::value, "");
     static_assert(!std::is_invocable<H, X const&>::value, "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
index cbf2c736e..17dfdce2d 100644
--- a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
@@ -52,8 +52,10 @@ void test_nullptr()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int*>();
     test_nullptr();
+
+  return 0;
 }
diff --git a/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
index 8da459ff8..90b09132d 100644
--- a/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
@@ -21,7 +21,7 @@ auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> )
 -> decltype ( std::make_tuple ( std::get<I>(t)... ))
 {     return  std::make_tuple ( std::get<I>(t)... ); }
 
-int main()
+int main(int, char**)
 {
 //  Make a couple of sequences
     using int3    = std::make_integer_sequence<int, 3>;     // generates int:    0,1,2
@@ -76,4 +76,6 @@ int main()
     auto tsizemix = extract ( tup, sizemix ());
     static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::size (), "tsizemix size wrong");
     assert ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 ));
+
+  return 0;
 }
diff --git a/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp b/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
index 44ffb0178..248b346e3 100644
--- a/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
+++ b/test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER > 11
 
@@ -36,4 +36,6 @@ int main()
 X
 
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
diff --git a/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
index 653d2988a..a8e14c9a9 100644
--- a/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
@@ -22,7 +22,7 @@
 #include <cstddef>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 //  Make a few of sequences
     using int3    = std::integer_sequence<int, 3, 2, 1>;
@@ -42,4 +42,6 @@ int main()
 
     static_assert ( std::is_same<bool0::value_type, bool>::value, "bool0 type wrong" );
     static_assert ( bool0::size() == 0, "bool0 size wrong" );
+
+  return 0;
 }
diff --git a/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp b/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
index 2f2a6608b..ec2e8cc7c 100644
--- a/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
+++ b/test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::make_integer_sequence<int, -3> MakeSeqT;
 
@@ -33,4 +33,6 @@ int main()
 #else
     MakeSeqT i; // expected-error@utility:* {{static_assert failed "std::make_integer_sequence must have a non-negative sequence length"}}
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp b/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
index 3c522c73b..50b49dd72 100644
--- a/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
+++ b/test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
@@ -17,7 +17,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_same<std::make_integer_sequence<int, 0>, std::integer_sequence<int>>::value, "");
     static_assert(std::is_same<std::make_integer_sequence<int, 1>, std::integer_sequence<int, 0>>::value, "");
@@ -28,4 +28,6 @@ int main()
     static_assert(std::is_same<std::make_integer_sequence<unsigned long long, 1>, std::integer_sequence<unsigned long long, 0>>::value, "");
     static_assert(std::is_same<std::make_integer_sequence<unsigned long long, 2>, std::integer_sequence<unsigned long long, 0, 1>>::value, "");
     static_assert(std::is_same<std::make_integer_sequence<unsigned long long, 3>, std::integer_sequence<unsigned long long, 0, 1, 2>>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/intseq/nothing_to_do.pass.cpp b/test/std/utilities/intseq/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/intseq/nothing_to_do.pass.cpp
+++ b/test/std/utilities/intseq/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp b/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
index b095dbfaf..1a58726a8 100644
--- a/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
+++ b/test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
@@ -15,7 +15,9 @@
 
 void test(std::allocator_arg_t) {}
 
-int main()
+int main(int, char**)
 {
     test(std::allocator_arg);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
index 60f267fa5..47cfbb049 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
@@ -42,9 +42,11 @@ struct A
     }
 };
 
-int main()
+int main(int, char**)
 {
     A<int> a;
     std::allocator_traits<A<int> >::allocate(a, 10);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::allocator_traits<A<int> >::allocate(a, 10, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
index a892be03d..0ac2f266e 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
@@ -33,7 +33,7 @@ struct A
     }
 };
 
-int main()
+int main(int, char**)
 {
   {
     A<int> a;
@@ -45,4 +45,6 @@ int main()
     Alloc a;
     assert(std::allocator_traits<Alloc >::allocate(a, 10) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
index 9d4631740..e95247163 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
@@ -53,7 +53,7 @@ struct B
 };
 
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
   {
@@ -77,4 +77,6 @@ int main()
     Alloc b;
     assert(std::allocator_traits<Alloc >::allocate(b, 11, nullptr) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
index 252d99a7a..67a2e8f4a 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
@@ -81,7 +81,7 @@ struct A2
 
 int A2::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A0::count = 0;
@@ -149,4 +149,6 @@ int main()
         assert(b_construct == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
index 94f10b64d..c738416e0 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
@@ -36,7 +36,7 @@ struct A
     }
 };
 
-int main()
+int main(int, char**)
 {
   {
     A<int> a;
@@ -51,4 +51,6 @@ int main()
     std::allocator_traits<Alloc >::deallocate(a, reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
     assert(called == 1);
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
index 677c647a2..70890d851 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
@@ -54,7 +54,7 @@ struct A0
 
 int A0::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A0::count = 0;
@@ -86,4 +86,6 @@ int main()
         assert(b_destroy == 1);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
index a51ec6e95..b758c9add 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
@@ -42,7 +42,7 @@ struct B
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         B<int> b;
@@ -74,4 +74,6 @@ int main()
         static_assert(noexcept(std::allocator_traits<std::allocator<int>>::max_size(a)) == true, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
index 9594531da..be837670d 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
@@ -47,7 +47,7 @@ struct B
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         A<int> a;
@@ -73,4 +73,6 @@ int main()
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
index f153d95b4..756958b58 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
@@ -55,7 +55,7 @@ private:
   typedef void const_pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_pointer, Ptr<const char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_pointer, const char*>::value), "");
@@ -63,4 +63,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::const_pointer, const char*>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
index 3acedde65..4fcc2fb7c 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
@@ -57,7 +57,7 @@ private:
     typedef int const_void_pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_void_pointer, Ptr<const void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_void_pointer, const void*>::value), "");
@@ -65,4 +65,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::const_void_pointer, const void*>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
index b0ee16350..35721f1cb 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
@@ -66,7 +66,7 @@ struct pointer_traits<C<char>::pointer>
 
 }
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::difference_type, short>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::difference_type, std::ptrdiff_t>::value), "");
@@ -74,4 +74,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::difference_type, std::ptrdiff_t>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
index fae618493..42b0fbab1 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
@@ -39,7 +39,7 @@ struct C
     int not_empty_;  // some random member variable
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::is_always_equal, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::is_always_equal, std::true_type>::value), "");
@@ -48,4 +48,6 @@ int main()
     static_assert((std::is_same<std::allocator_traits<A<const char> >::is_always_equal, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<const char> >::is_always_equal, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<const char> >::is_always_equal, std::false_type>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
index 60f3d257a..58b306660 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
@@ -43,11 +43,13 @@ private:
     typedef void pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::pointer, Ptr<char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::pointer, char*>::value), "");
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::pointer, char*>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
index c8451b2a9..b049159e2 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
@@ -43,11 +43,13 @@ private:
     typedef std::true_type propagate_on_container_copy_assignment;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_copy_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
index 7c58ac881..602ba96d5 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
@@ -44,11 +44,13 @@ private:
 };
 
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_move_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
index 7a6bcd460..5ae53015f 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
@@ -42,11 +42,13 @@ private:
     typedef std::true_type propagate_on_container_swap;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_swap, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_swap, std::false_type>::value), "");
  #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_swap, std::false_type>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
index eaadeb170..d0d8476a8 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
@@ -80,7 +80,7 @@ struct G {
     };
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_alloc<double>, ReboundA<double> >::value), "");
@@ -97,4 +97,6 @@ int main()
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_alloc<double>::other, D<double, char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_alloc<double>::other, E<double> >::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
index 42b29a39c..cd7467139 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
@@ -62,7 +62,7 @@ struct pointer_traits<C<char>::pointer>
 
 }
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::size_type, unsigned short>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::size_type,
@@ -72,4 +72,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::size_type, unsigned short>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
index 687d892f0..55954dc70 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
@@ -56,7 +56,7 @@ private:
     typedef void void_pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::void_pointer, Ptr<void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::void_pointer, void*>::value), "");
@@ -64,4 +64,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::void_pointer, void*>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
index d5977f0a2..840ad820e 100644
--- a/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
@@ -24,7 +24,9 @@ struct A
     typedef T value_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::allocator_type, A<char> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp b/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
index 475ab04b8..01aac9445 100644
--- a/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
@@ -62,7 +62,7 @@ struct E
     template <class U> struct rebind {typedef ReboundA<U> otter;};
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_traits<double>, std::allocator_traits<ReboundA<double> > >::value), "");
@@ -77,4 +77,6 @@ int main()
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_traits<double>::other, std::allocator_traits<D<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_traits<double>::other, std::allocator_traits<E<double> > >::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.traits/value_type.pass.cpp b/test/std/utilities/memory/allocator.traits/value_type.pass.cpp
index dec3a41e3..047d40d5c 100644
--- a/test/std/utilities/memory/allocator.traits/value_type.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/value_type.pass.cpp
@@ -24,7 +24,9 @@ struct A
     typedef T value_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::value_type, char>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp b/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp b/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
index 5b7f710ea..d9d4fc3d8 100644
--- a/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
+++ b/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
@@ -47,7 +47,7 @@ test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<false, int, std::allocator<int> >();
     test<true, std::vector<int>, std::allocator<int> >();
@@ -71,4 +71,6 @@ int main()
 // #if TEST_STD_VER >= 11
 //     static_assert((!std::uses_allocator<E, int>::value), "");
 // #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp b/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp b/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
index a8d90b1ce..7e6c67800 100644
--- a/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
@@ -8,6 +8,8 @@
 
 // <cstdlib> and <cstring> are already tested elsewhere
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
index 7aa2dbfeb..57946be08 100644
--- a/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::allocator<char> AC;
@@ -46,4 +46,6 @@ int main()
     (void) a3;
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
index b38daf8e9..63412bce1 100644
--- a/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
@@ -21,10 +21,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::allocator<int> a1;
     std::allocator<int> a2;
     assert(a1 == a2);
     assert(!(a1 != a2));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
index bb1bb4f11..c4ff55d0e 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
@@ -31,8 +31,10 @@ struct A
     void operator&() const {}
 };
 
-int main()
+int main(int, char**)
 {
     test_address<int>();
     test_address<A>();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
index df4124f51..889804f3b 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
@@ -19,9 +19,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::allocator<int> a;
     a.allocate(3);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
index 14e5a8a3c..8392cbdb7 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
@@ -99,7 +99,7 @@ void test_aligned() {
   }
 }
 
-int main() {
+int main(int, char**) {
     test_aligned<1>();
     test_aligned<2>();
     test_aligned<4>();
@@ -108,4 +108,6 @@ int main() {
     test_aligned<MaxAligned>();
     test_aligned<OverAligned>();
     test_aligned<OverAligned * 2>();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
index 09a9bd912..685e02ef3 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
@@ -39,8 +39,10 @@ void test()
     test_max<T> ((size_t) -1);                     // way too large
 }
 
-int main()
+int main(int, char**)
 {
     test<double>();
     LIBCPP_ONLY(test<const double>());
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
index 322881b15..96954e04b 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
@@ -53,7 +53,7 @@ public:
 };
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     {
     std::allocator<A> a;
@@ -139,4 +139,6 @@ int main()
     assert(move_only_constructed == 0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
index 50076ce02..c2094bc04 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
@@ -18,9 +18,11 @@
 
 int new_called = 0;
 
-int main()
+int main(int, char**)
 {
     const std::allocator<int> a;
     std::size_t M = a.max_size();
     assert(M > 0xFFFF && M <= (std::numeric_limits<std::size_t>::max() / sizeof(int)));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
index 375b96f83..bc89c62a8 100644
--- a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
@@ -108,7 +108,7 @@ void test_void_pointer()
 
 struct Foo { int x; };
 
-int main()
+int main(int, char**)
 {
     test_pointer<std::allocator<char>> ();
     test_pointer<std::allocator<int>> ();
@@ -117,7 +117,9 @@ int main()
     test_void_pointer<std::allocator<char>> ();
     test_void_pointer<std::allocator<int>> ();
     test_void_pointer<std::allocator<Foo>> ();
+
+  return 0;
 }
 #else
-int main() {}
+int main(int, char**) { return 0; }
 #endif
diff --git a/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
index 9cd581564..0bff67efb 100644
--- a/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), "");
     static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), "");
@@ -53,4 +53,6 @@ int main()
     a2 = a;
     std::allocator<int> a3 = a2;
     ((void)a3);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
index 1f13c8be6..528902d21 100644
--- a/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
@@ -22,7 +22,7 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), "");
     static_assert((std::is_same<std::allocator<void>::const_pointer, const void*>::value), "");
@@ -32,4 +32,6 @@ int main()
     std::allocator<void> a;
     std::allocator<void> a2 = a;
     a2 = a;
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp b/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
index 0fd45fd91..7d55974dd 100644
--- a/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
+++ b/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
@@ -99,7 +99,7 @@ struct pointer_traits<::P4>
 int n = 0;
 static_assert(std::to_address(&n) == &n);
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     ASSERT_NOEXCEPT(std::to_address(&i));
@@ -116,4 +116,6 @@ int main()
     P4 p4(&i);
     ASSERT_NOEXCEPT(std::to_address(p4));
     assert(std::to_address(p4) == &i);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp b/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
index 867bd46cd..3eaedab16 100644
--- a/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
@@ -18,7 +18,9 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<double*>::difference_type, std::ptrdiff_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/element_type.pass.cpp b/test/std/utilities/memory/pointer.traits/element_type.pass.cpp
index 42db90ff6..505881dde 100644
--- a/test/std/utilities/memory/pointer.traits/element_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/element_type.pass.cpp
@@ -18,7 +18,9 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<const short*>::element_type, const short>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.pass.cpp
index 4a74b5d58..110a993dc 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.pass.cpp
@@ -24,8 +24,10 @@ struct A
     typedef char difference_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<A>::pointer, A>::value), "");
     static_assert((std::is_same<std::pointer_traits<int*>::pointer, int*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
index 0b412dac4..9e6a48930 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
@@ -34,7 +34,7 @@ public:
         {return A(&et);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         int i = 0;
@@ -45,4 +45,6 @@ int main()
     {
         (std::pointer_traits<A<void> >::element_type)0;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
index 7e0823539..d4d763c69 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
@@ -52,7 +52,7 @@ private:
   typedef int difference_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<A>::difference_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<B>::difference_type, std::ptrdiff_t>::value), "");
@@ -62,4 +62,6 @@ int main()
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<F<int>>::difference_type, std::ptrdiff_t>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
index 8184d2d00..c0efdeab0 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
@@ -53,7 +53,7 @@ private:
   typedef int element_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<A>::element_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<B<int> >::element_type, char>::value), "");
@@ -64,4 +64,6 @@ int main()
     static_assert((std::is_same<std::pointer_traits<F<double>>::element_type, double>::value), "");
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
index 407f4bcfb..a79f33916 100644
--- a/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
@@ -81,7 +81,7 @@ struct G
 #endif
 
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<A<int*> >::rebind<double*>, A<double*> >::value), "");
@@ -101,4 +101,6 @@ int main()
     static_assert((std::is_same<std::pointer_traits<D<char, int> >::rebind<double>::other, D1<double, int> >::value), "");
     static_assert((std::is_same<std::pointer_traits<E<char, int> >::rebind<double>::other, E<double, int> >::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp b/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
index 968d3ee1e..e9b858c7f 100644
--- a/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
@@ -35,9 +35,11 @@ bool check() {
     return true;
 }
 
-int main() {
+int main(int, char**) {
     check();
 #if TEST_STD_VER > 17
     static_assert(check(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/pointer.traits/rebind.pass.cpp b/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
index 823d4f11f..f64213c9b 100644
--- a/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
+++ b/test/std/utilities/memory/pointer.traits/rebind.pass.cpp
@@ -20,11 +20,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>, double*>::value), "");
 #else
     static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>::other, double*>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/ptr.align/align.pass.cpp b/test/std/utilities/memory/ptr.align/align.pass.cpp
index c7a181eb7..3d0216cce 100644
--- a/test/std/utilities/memory/ptr.align/align.pass.cpp
+++ b/test/std/utilities/memory/ptr.align/align.pass.cpp
@@ -13,7 +13,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const unsigned N = 20;
     char buf[N];
@@ -80,4 +80,6 @@ int main()
     assert(p == &buf[0]);
     assert(r == nullptr);
     assert(s == N);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp b/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
index 956e6b118..f6310c7bc 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
@@ -26,7 +26,7 @@ struct nothing {
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
     int i;
@@ -47,4 +47,6 @@ int main()
     };
     assert(std::addressof(n) == (void*)std::addressof(i));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
index c12bf41e8..f7033014d 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
@@ -15,11 +15,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER > 14
     const int *p = std::addressof<const int>(0);
 #else
 #error
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
index c042dd5c3..f14a0e7fc 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
@@ -32,10 +32,12 @@ constexpr int i = 0;
 constexpr double d = 0.0;
 constexpr A a{};
 
-int main()
+int main(int, char**)
 {
     static_assert(std::addressof(i) == &i, "");
     static_assert(std::addressof(d) == &d, "");
     constexpr const A* ap = std::addressof(a);
     static_assert(&ap->n == &a.n, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
index f812bb85a..4dbc20aba 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
@@ -30,7 +30,7 @@ struct Counted {
 };
 int Counted::count = 0;
 
-int main()
+int main(int, char**)
 {
     using It = forward_iterator<Counted*>;
     const int N = 5;
@@ -43,4 +43,6 @@ int main()
     assert(Counted::count == 4);
     std::destroy(It(p), It(p + 4));
     assert(Counted::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
index 28450faa1..d505222b0 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
@@ -41,7 +41,7 @@ struct DCounted : VCounted {
     friend void operator&(DCounted) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
     void* mem1 = std::malloc(sizeof(Counted));
@@ -74,4 +74,6 @@ int main()
     std::free(mem1);
     std::free(mem2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
index 90836b233..0dcc8e5a6 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
@@ -30,7 +30,7 @@ struct Counted {
 };
 int Counted::count = 0;
 
-int main()
+int main(int, char**)
 {
     using It = forward_iterator<Counted*>;
     const int N = 5;
@@ -45,4 +45,6 @@ int main()
     It it = std::destroy_n(It(p), 4);
     assert(it == It(p+4));
     assert(Counted::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
index bd9ef7b40..67dd6fbd2 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
@@ -103,9 +103,11 @@ void test_value_initialized()
     assert(pool[4] == -1);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
     test_ctor_throws();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
index d2f6e094a..1052355a4 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
@@ -107,9 +107,11 @@ void test_value_initialized()
 }
 
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
     test_ctor_throws();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
index 50ce12248..5dfcd83fe 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
@@ -102,9 +102,11 @@ void test_value_initialized()
     assert(pool[4] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
     test_ctor_throws();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
index 4d89f9cac..e43102ba4 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
@@ -107,8 +107,10 @@ void test_value_initialized()
     assert(pool[4] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
index b81d561e0..2618bd533 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
@@ -47,7 +47,7 @@ struct Nasty
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -85,4 +85,6 @@ int main()
         }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
index c3f46bebe..1a237a792 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
@@ -47,7 +47,7 @@ struct Nasty
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -84,4 +84,6 @@ int main()
         assert(  p[i].i_ == i);
     }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
index 5c177663e..4dfde4f6e 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
@@ -46,7 +46,7 @@ struct Nasty
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -84,4 +84,6 @@ int main()
     }
 
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
index f7790fc45..1996ec6c6 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
@@ -47,7 +47,7 @@ struct Nasty
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -81,4 +81,6 @@ int main()
     for (int i = 0; i < N; ++i)
         assert(bp[i].i_ == 23);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
index a0717e61b..e17f5734b 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
@@ -107,7 +107,9 @@ void test_counted()
     assert(Counted::count == 0);
 }
 
-int main() {
+int main(int, char**) {
     test_counted();
     test_ctor_throws();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
index 755384074..ee364aaf5 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
@@ -109,8 +109,10 @@ void test_counted()
     assert(Counted::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_ctor_throws();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
index 531158ba1..5355d09ac 100644
--- a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
+++ b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
@@ -36,7 +36,7 @@ public:
     A* operator& () DELETE_FUNCTION;
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 14
     typedef std::aligned_storage<3*sizeof(A), std::alignment_of<A>::value>::type
@@ -54,4 +54,6 @@ int main()
         assert(it.base() == ap + 1);  // next place to write
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
index 90bb956fc..2b9b33fd9 100644
--- a/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
+++ b/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
@@ -36,7 +36,7 @@ public:
     A* operator& () DELETE_FUNCTION;
 };
 
-int main()
+int main(int, char**)
 {
     {
     typedef A S;
@@ -67,4 +67,6 @@ int main()
     assert(ap->get() == 1); // original value
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp b/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
index fd818577b..db71c69bf 100644
--- a/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
+++ b/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
@@ -25,10 +25,12 @@ struct alignas(32) A {
     int field;
 };
 
-int main()
+int main(int, char**)
 {
     std::pair<A*, std::ptrdiff_t> ip = std::get_temporary_buffer<A>(5);
     assert(!(ip.first == nullptr) ^ (ip.second == 0));
     assert(reinterpret_cast<uintptr_t>(ip.first) % alignof(A) == 0);
     std::return_temporary_buffer(ip.first);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp b/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
index 22efde4af..32a58e5a6 100644
--- a/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
+++ b/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
@@ -19,10 +19,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::pair<int*, std::ptrdiff_t> ip = std::get_temporary_buffer<int>(5);
     assert(ip.first);
     assert(ip.second == 5);
     std::return_temporary_buffer(ip.first);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
index c9d1c8b46..bc6846fe7 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
@@ -26,9 +26,11 @@
 #include "min_allocator.h"
 #include "deleter_types.h"
 
-int main()
+int main(int, char**)
 {
     std::unique_ptr<int, PointerDeleter<int>> p;
     std::ostringstream os;
     os << p; // expected-error {{invalid operands to binary expression}}
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
index e350a0385..b9b158a9d 100644
--- a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
@@ -21,11 +21,13 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::unique_ptr<int> p(new int(3));
     std::ostringstream os;
     assert(os.str().empty());
     os << p;
     assert(!os.str().empty());
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp b/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
index 5c99a9721..a2b6cf22e 100644
--- a/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
+++ b/test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
@@ -13,10 +13,12 @@
 
 #include <memory>
 
-int main()
+int main(int, char**)
 {
     char* p = new char[10];
     std::declare_no_pointers(p, 10);
     std::undeclare_no_pointers(p, 10);
     delete [] p;
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp b/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
index 4a71817d4..c923089fa 100644
--- a/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
+++ b/test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
@@ -14,10 +14,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int* p = new int;
     std::declare_reachable(p);
     assert(std::undeclare_reachable(p) == p);
     delete p;
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp b/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
index 4fc2e010f..2fea98364 100644
--- a/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
+++ b/test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
@@ -22,7 +22,7 @@ void test_pr26961() {
   assert(d == std::get_pointer_safety());
 }
 
-int main()
+int main(int, char**)
 {
   {
     std::pointer_safety r = std::get_pointer_safety();
@@ -33,4 +33,6 @@ int main()
   {
     test_pr26961();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp b/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
index 0f7c44fd8..fe7567eeb 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
@@ -52,7 +52,7 @@ struct PrivateBase : private std::enable_shared_from_this<PrivateBase> {
 };
 
 
-int main()
+int main(int, char**)
 {
     {  // https://bugs.llvm.org/show_bug.cgi?id=18843
     std::shared_ptr<T const> t1(new T);
@@ -167,4 +167,6 @@ int main()
         assert(my_weak.lock().get() == ptr);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
index bd7f644c3..440fa8ac4 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
index 8db542c07..34717ad42 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
@@ -25,7 +25,7 @@
 struct A {};
 #endif
 
-int main()
+int main(int, char**)
 {
   {
     int* ptr = new int;
@@ -40,4 +40,6 @@ int main()
     test_hash_enabled_for_type<std::shared_ptr<A>>();
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
index 4f942f6c2..5cae6ca7d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
@@ -60,7 +60,7 @@ struct A {};
 
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
   {
     int* ptr = new int;
@@ -99,4 +99,6 @@ int main()
 #endif
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
index 45c82c4ba..7737cfd4d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -51,4 +51,6 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
index d1589aadd..9198ca68c 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -56,4 +56,6 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
index fb09a19fd..da52811c9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -51,4 +51,6 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
index 2a9b6ce12..703bf008f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -56,4 +56,6 @@ int main()
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
index cf6ad5b00..b51a24aef 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -37,4 +37,6 @@ int main()
         assert(*p == 3);
         assert(*r == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
index f177420fe..b59b515a5 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -37,4 +37,6 @@ int main()
         assert(*p == 3);
         assert(*r == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
index 3b267f99d..e8bb64dcc 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
@@ -23,10 +23,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<int> p(new int(3));
         assert(std::atomic_is_lock_free(&p) == false);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
index b36580ef2..63416faf3 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
@@ -28,11 +28,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load(&p);
         assert(*q == *p);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
index 40f6b49d6..0708f874b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
@@ -28,11 +28,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load_explicit(&p, std::memory_order_relaxed);
         assert(*q == *p);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
index 3c6de40f1..42d7099a9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p;
@@ -36,4 +36,6 @@ int main()
         std::atomic_store(&p, r);
         assert(*p == *r);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
index dd4001a82..7da4de3fa 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p;
@@ -36,4 +36,6 @@ int main()
         std::atomic_store_explicit(&p, r, std::memory_order_seq_cst);
         assert(*p == *r);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
index 4a96f8181..c3aedd5b1 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
@@ -22,10 +22,12 @@
 
 struct A;  // purposefully incomplete
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::shared_ptr<A>::element_type, A>::value), "");
 #if TEST_STD_VER > 14
     static_assert((std::is_same<std::shared_ptr<A>::weak_type, std::weak_ptr<A>>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
index babf1c6ee..209e3fe71 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         {
@@ -63,4 +63,6 @@ int main()
         std::default_delete<A>* d = std::get_deleter<std::default_delete<A> >(p);
         assert(d == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
index 69ad9513b..a154a121c 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
@@ -40,7 +40,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::auto_ptr<A> pA(new A);
@@ -110,4 +110,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
index 6d2000c13..e362f4d8d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -117,4 +117,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
index 23b587d0b..2b666315e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -117,4 +117,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
index a3ba5877f..6787c33c2 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
@@ -41,7 +41,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -119,4 +119,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
index 8c63b14b2..e921a0991 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
@@ -41,7 +41,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -119,4 +119,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
index b7fc447b0..4abe371bc 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_ptr<A> pA(new A);
@@ -109,4 +109,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
index 53955aaa2..51e2949b6 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<const A> pA(new A);
@@ -53,4 +53,6 @@ int main()
         assert(pB.get() == pA.get());
         assert(!pB.owner_before(pA) && !pA.owner_before(pB));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
index c27f9503b..76009b96a 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<B> pB(new A);
@@ -53,4 +53,6 @@ int main()
         assert(pA.get() == 0);
         assert(pA.use_count() == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
index ec72834d5..9ea544fee 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -65,4 +65,6 @@ int main()
         assert(pB.get() == pA.get());
         assert(!pB.owner_before(pA) && !pA.owner_before(pB));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
index 6936744c1..98b5bbf0d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
@@ -40,7 +40,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int(1));
     assert(!(p1 == nullptr));
@@ -65,4 +65,6 @@ int main()
     assert(!(nullptr > p2));
     assert( (p2 >= nullptr));
     assert( (nullptr >= p2));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
index 1257ea65f..e25ba6117 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
@@ -18,7 +18,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     int* ptr1(new int);
     int* ptr2(new int);
@@ -27,4 +27,6 @@ int main()
     const std::shared_ptr<int> p3(ptr2, do_nothing);
     assert(p1 != p2);
     assert(p2 == p3);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
index 15e13688b..fdef32d51 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
@@ -17,7 +17,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     int* ptr1(new int);
     int* ptr2(new int);
@@ -26,4 +26,6 @@ int main()
     const std::shared_ptr<int> p3(ptr2, do_nothing);
     assert((p1 < p2) == (ptr1 < ptr2));
     assert(!(p2 < p3) && !(p3 < p2));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
index 6558e230d..282ddd0e0 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
@@ -43,7 +43,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::auto_ptr<A> ptr(new A);
@@ -94,4 +94,6 @@ int main()
     assert(A::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
index c70e537a9..247ca0fa9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
@@ -13,9 +13,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<int> p;
     assert(p.use_count() == 0);
     assert(p.get() == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
index a46b31aa5..f29dd1cf7 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
@@ -13,9 +13,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<int> p(nullptr);
     assert(p.use_count() == 0);
     assert(p.get() == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
index 9644e4f0f..ee5861122 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     std::shared_ptr<A> p(nullptr, test_deleter<A>(3));
@@ -43,4 +43,6 @@ int main()
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
index bc1d3584e..0881e8cf4 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5));
@@ -81,4 +81,6 @@ int main()
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
index 1948c6860..4700df008 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     try
     {
@@ -43,4 +43,6 @@ int main()
         assert(test_allocator<A>::count == 0);
         assert(test_allocator<A>::alloc_count == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
index 075cadf43..7d2628d60 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
@@ -37,7 +37,7 @@ struct A
 int A::count = 0;
 
 
-int main()
+int main(int, char**)
 {
     globalMemCounter.throw_after = 0;
     try
@@ -51,4 +51,6 @@ int main()
         assert(test_deleter<A>::count == 0);
         assert(test_deleter<A>::dealloc_count == 1);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
index 67f0ffd2a..b55d764a6 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
@@ -24,7 +24,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     A* ptr = new A;
@@ -42,4 +42,6 @@ int main()
     assert(p.get() == ptr);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
index 120171456..fd9819382 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     A* ptr = new A;
@@ -44,4 +44,6 @@ int main()
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
index 79a0bc84a..0ec18a7ae 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
@@ -28,7 +28,7 @@ struct A
 int A::count = 0;
 
 
-int main()
+int main(int, char**)
 {
     {
     A* ptr = new A;
@@ -85,4 +85,6 @@ int main()
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
index ad020f89f..5f2984c7e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     A* ptr = new A;
     try
@@ -44,4 +44,6 @@ int main()
         assert(test_allocator<A>::count == 0);
         assert(test_allocator<A>::alloc_count == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
index 6af99aaf5..da12e42ca 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
@@ -34,7 +34,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     A* ptr = new A;
     globalMemCounter.throw_after = 0;
@@ -50,4 +50,6 @@ int main()
         assert(test_deleter<A>::dealloc_count == 1);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
index 95da6f691..15e776003 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
@@ -33,7 +33,7 @@ struct A
 int A::count = 0;
 
 
-int main()
+int main(int, char**)
 {
     A* ptr = new A;
     assert(A::count == 1);
@@ -48,4 +48,6 @@ int main()
         assert(A::count == 0);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
index 44a5be471..091782f02 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -58,4 +58,6 @@ int main()
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
index 3b7279087..01a74898f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
@@ -50,7 +50,7 @@ struct C
 
 int C::count = 0;
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::shared_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<B>, std::shared_ptr<A> >::value), "");
@@ -93,4 +93,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
index 8d3af186e..cc86d12df 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
@@ -54,7 +54,7 @@ struct C
 
 int C::count = 0;
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::shared_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<B>, std::shared_ptr<A> >::value), "");
@@ -109,4 +109,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
index 06a285cd2..83a9a9720 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
@@ -37,7 +37,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -57,4 +57,6 @@ int main()
     }
     assert(A::count == 0);
     assert(B::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
index d9eef4a23..86797a047 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
@@ -30,7 +30,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -73,4 +73,6 @@ int main()
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
index d235a50b9..6fd812fca 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
@@ -49,7 +49,7 @@ void fn ( const std::shared_ptr<B> &) { assert (false); }
 template <typename T>
 void assert_deleter ( T * ) { assert(false); }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_ptr<A> ptr(new A);
@@ -97,4 +97,6 @@ int main()
         std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
index 117a74aaa..9174f39be 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
@@ -40,7 +40,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
@@ -81,4 +81,6 @@ int main()
     }
     assert(A::count == 0);
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
index 354a23e70..06c2bba67 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
@@ -51,7 +51,7 @@ private:
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     int i = 67;
@@ -82,4 +82,6 @@ int main()
     assert(p->get_char() == 'f');
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
index 0783b6e7f..00f79cc19 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
@@ -97,7 +97,7 @@ void test()
     assert(Three::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int i = 67;
@@ -114,4 +114,6 @@ int main()
 #if TEST_STD_VER >= 11
     test<min_allocator<void> >();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
index 2535519b9..aed060e57 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
@@ -73,7 +73,7 @@ void test_pointer_to_function() {
 void test_pointer_to_function() {}
 #endif // _LIBCPP_VERSION
 
-int main()
+int main(int, char**)
 {
     int nc = globalMemCounter.outstanding_new;
     {
@@ -107,4 +107,6 @@ int main()
     }
 #endif
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
index fd5ebdcca..e17d7424b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
@@ -22,7 +22,9 @@ private:
    S () {};  // ctor is private
 };
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<S> p = std::make_shared<S>();
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
index 8ba4a69c3..d4d8fb630 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
@@ -22,7 +22,9 @@ protected:
    S () {};  // ctor is protected
 };
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<S> p = std::make_shared<S>();  // expected-error-re@memory:* {{static_assert failed{{.*}} "Can't construct object in make_shared"}}
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
index c50b68f70..aa038f747 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
@@ -52,9 +52,11 @@ void test(const T &t0)
 
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(true);
     test<int>(3);
     test<double>(5.0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
index cf3aac86a..b09550a6e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
@@ -18,11 +18,13 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<int> p(new int(3));
     std::ostringstream os;
     assert(os.str().empty());
     os << p;
     assert(!os.str().empty());
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
index 3943b5892..c9df00319 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
@@ -38,7 +38,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -58,4 +58,6 @@ int main()
         assert(p.get() == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
index 3e91fa3de..c35824165 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
@@ -38,7 +38,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -60,4 +60,6 @@ int main()
         assert(p.get() == ptr);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
index 70a2024cc..e7d457fa1 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -75,4 +75,6 @@ int main()
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 2);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
index d4db96826..9e2bd1012 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
@@ -40,7 +40,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -84,4 +84,6 @@ int main()
     assert(test_deleter<A>::dealloc_count == 2);
     assert(test_allocator<A>::count == 0);
     assert(test_allocator<A>::alloc_count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
index a47e67f04..a27949ebb 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -100,4 +100,6 @@ int main()
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
index 5f7d6582b..77bf3a22e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
@@ -16,7 +16,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<std::pair<int, int> > p(new std::pair<int, int>(3, 4));
     assert(p->first == 3);
@@ -25,4 +25,6 @@ int main()
     p->second = 6;
     assert(p->first == 5);
     assert(p->second == 6);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
index 4b2a495a8..a6f75533a 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
@@ -15,10 +15,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p(new int(32));
     assert(*p == 32);
     *p = 3;
     assert(*p == 3);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
index 4c6790f86..247deb07b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
@@ -15,7 +15,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     const std::shared_ptr<int> p(new int(32));
@@ -25,4 +25,6 @@ int main()
     const std::shared_ptr<int> p;
     assert(!p);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
index c6ae19911..497a53b21 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -26,4 +26,6 @@ int main()
     assert(p1.owner_before(p3) || p3.owner_before(p1));
     assert(p3.owner_before(p1) == p3.owner_before(p2));
     ASSERT_NOEXCEPT(p1.owner_before(p2));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
index e857aa6a8..07c7a0644 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -29,4 +29,6 @@ int main()
     assert(p1.owner_before(w3) || p3.owner_before(w1));
     assert(p3.owner_before(w1) == p3.owner_before(w2));
     ASSERT_NOEXCEPT(p1.owner_before(w2));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
index 14a2fe992..dfad31385 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
@@ -15,7 +15,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p(new int(32));
     assert(p.unique());
@@ -24,4 +24,6 @@ int main()
     assert(!p.unique());
     }
     assert(p.unique());
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.spec/swap.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.spec/swap.pass.cpp
index b40e4705a..b0bfcae9a 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.spec/swap.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.spec/swap.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -101,4 +101,6 @@ int main()
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
index 2263eb810..f5bdb876b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
@@ -19,7 +19,9 @@
 
 struct A;  // purposefully incomplete
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::weak_ptr<A>::element_type, A>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
index c65755d8e..b3cc13d72 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
@@ -52,7 +52,7 @@
 
 struct X {};
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -128,4 +128,6 @@ int main()
     assert(s.find(vp) == s.end());
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
index 1362537e0..02f180d3d 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -57,4 +57,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
index 739165c3c..f41c391c4 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> ps(new A);
@@ -74,4 +74,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
index f763dc463..33b2ddd42 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> ps(new A);
@@ -74,4 +74,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
index b29623f29..e5a70abe4 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
@@ -17,8 +17,10 @@
 
 struct A;
 
-int main()
+int main(int, char**)
 {
     std::weak_ptr<A> p;
     assert(p.use_count() == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
index 8aaeab0c9..45be55e66 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
@@ -50,7 +50,7 @@ struct C
 
 int C::count = 0;
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::weak_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::weak_ptr<B>, std::shared_ptr<A> >::value), "");
@@ -91,4 +91,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
index 351b66323..658b233c4 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
@@ -61,7 +61,7 @@ template <class T>
 void sink (std::weak_ptr<T> &&) {}
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> ps(new A);
@@ -112,4 +112,6 @@ int main()
     assert(B::count == 0);
     assert(A::count == 0);
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
index e155e4faa..4268fda3a 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
@@ -54,7 +54,7 @@ int C::count = 0;
 template <class T>
 std::weak_ptr<T> source (std::shared_ptr<T> p) { return std::weak_ptr<T>(p); }
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::weak_ptr<A>, std::weak_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::weak_ptr<B>, std::weak_ptr<A> >::value), "");
@@ -104,4 +104,6 @@ int main()
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
index 7c3bcb6c6..eae249ca1 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> p1(new A);
@@ -37,4 +37,6 @@ int main()
         assert(p1.use_count() == 1);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
index 38b1dee09..76703d0dd 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -45,4 +45,6 @@ int main()
         }
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
index f2fccb558..5fb2dd4f9 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::weak_ptr<A> wp;
@@ -42,4 +42,6 @@ int main()
         assert(wp.use_count() == 0);
         assert(wp.expired() == (wp.use_count() == 0));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
index 883de740c..50ff84318 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
@@ -26,7 +26,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::weak_ptr<A> wp;
@@ -54,4 +54,6 @@ int main()
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
index c916a8907..2df6d6a0e 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
@@ -15,7 +15,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2(new int);
@@ -23,4 +23,6 @@ int main()
     const std::weak_ptr<int> w2(p2);
 
     bool b = w1 < w2;
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
index d8483d9b6..4d26f5f2b 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -29,4 +29,6 @@ int main()
     assert(w1.owner_before(p3) || w3.owner_before(p1));
     assert(w3.owner_before(p1) == w3.owner_before(p2));
     ASSERT_NOEXCEPT(w1.owner_before(p2));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
index b323da7d5..39993cd8f 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -29,4 +29,6 @@ int main()
     assert(w1.owner_before(w3) || w3.owner_before(w1));
     assert(w3.owner_before(w1) == w3.owner_before(w2));
     ASSERT_NOEXCEPT(w1.owner_before(w2));
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.spec/swap.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.spec/swap.pass.cpp
index e13d5aeaf..53bc3eb9c 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.spec/swap.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.spec/swap.pass.cpp
@@ -27,7 +27,7 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -46,4 +46,6 @@ int main()
         }
     }
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
index a85120ae0..f3e26dee5 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_weak_ptr>::value), "");
     std::bad_weak_ptr e;
     std::bad_weak_ptr e2 = e;
     e2 = e;
     assert(std::strcmp(e.what(), "bad_weak_ptr") == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.help/bool_constant.pass.cpp b/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
index b9037f527..917f8b919 100644
--- a/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
+++ b/test/std/utilities/meta/meta.help/bool_constant.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER > 14
     typedef std::bool_constant<true> _t;
@@ -30,4 +30,6 @@ int main()
     static_assert((std::is_same<_f::type, _f>::value), "");
     static_assert((_f() == false), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.help/integral_constant.pass.cpp b/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
index 89d648750..f312acad6 100644
--- a/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
+++ b/test/std/utilities/meta/meta.help/integral_constant.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::integral_constant<int, 5> _5;
     static_assert(_5::value == 5, "");
@@ -47,4 +47,6 @@ int main()
     std::true_type t1;
     std::true_type t2 = t1;
     assert(t2);
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.logical/conjunction.pass.cpp b/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
index 0b9a03621..e37769576 100644
--- a/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/conjunction.pass.cpp
@@ -19,7 +19,7 @@
 struct True  { static constexpr bool value = true; };
 struct False { static constexpr bool value = false; };
 
-int main()
+int main(int, char**)
 {
     static_assert ( std::conjunction<>::value, "" );
     static_assert ( std::conjunction<std::true_type >::value, "" );
@@ -62,4 +62,6 @@ int main()
 
     static_assert ( std::conjunction_v<True >, "" );
     static_assert (!std::conjunction_v<False>, "" );
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.logical/disjunction.pass.cpp b/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
index 00a1b306d..baaed6f03 100644
--- a/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/disjunction.pass.cpp
@@ -19,7 +19,7 @@
 struct True  { static constexpr bool value = true; };
 struct False { static constexpr bool value = false; };
 
-int main()
+int main(int, char**)
 {
     static_assert (!std::disjunction<>::value, "" );
     static_assert ( std::disjunction<std::true_type >::value, "" );
@@ -62,4 +62,6 @@ int main()
 
     static_assert ( std::disjunction_v<True >, "" );
     static_assert (!std::disjunction_v<False>, "" );
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.logical/negation.pass.cpp b/test/std/utilities/meta/meta.logical/negation.pass.cpp
index d399a5c84..88ca693d3 100644
--- a/test/std/utilities/meta/meta.logical/negation.pass.cpp
+++ b/test/std/utilities/meta/meta.logical/negation.pass.cpp
@@ -19,7 +19,7 @@
 struct True  { static constexpr bool value = true; };
 struct False { static constexpr bool value = false; };
 
-int main()
+int main(int, char**)
 {
     static_assert (!std::negation<std::true_type >::value, "" );
     static_assert ( std::negation<std::false_type>::value, "" );
@@ -35,4 +35,6 @@ int main()
 
     static_assert ( std::negation<std::negation<std::true_type >>::value, "" );
     static_assert (!std::negation<std::negation<std::false_type>>::value, "" );
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp b/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
index c2b84b354..ec27581a4 100644
--- a/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
@@ -40,7 +40,7 @@ struct B1 : B {};
 struct B2 : B {};
 struct D : private B1, private B2 {};
 
-int main()
+int main(int, char**)
 {
     test_is_base_of<B, D>();
     test_is_base_of<B1, D>();
@@ -53,4 +53,6 @@ int main()
     test_is_not_base_of<B&, D&>();
     test_is_not_base_of<B[3], D[3]>();
     test_is_not_base_of<int, int>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp b/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
index faffaf6b3..b1722b0fc 100644
--- a/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
@@ -60,7 +60,7 @@ class CannotInstantiate {
   enum { X = T::ThisExpressionWillBlowUp };
 };
 
-int main()
+int main(int, char**)
 {
     // void
     test_is_convertible<void,void> ();
@@ -259,4 +259,6 @@ int main()
     // Ensure that CannotInstantiate is not instantiated by is_convertible when it is not needed.
     // For example CannotInstantiate is instatiated as a part of ADL lookup for arguments of type CannotInstantiate*.
     static_assert((std::is_convertible<CannotInstantiate<int>*, CannotInstantiate<int>*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
index dab17974b..fa0c0c82e 100644
--- a/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
@@ -46,7 +46,7 @@ struct Sink {
   void operator()(Args&&...) const {}
 };
 
-int main() {
+int main(int, char**) {
   using AbominableFunc = void(...) const;
 
   //  Non-callable things
@@ -241,4 +241,5 @@ int main() {
   static_assert(std::is_invocable_r_v<void, Fn>, "");
   static_assert(!std::is_invocable_r_v<int, Fn>, "");
 }
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
index f21e99b02..baf64c12f 100644
--- a/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
@@ -80,7 +80,7 @@ void test_noexcept_function_pointers() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   using AbominableFunc = void(...) const noexcept;
   //  Non-callable things
   {
@@ -212,4 +212,6 @@ int main() {
     static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
   }
   test_noexcept_function_pointers();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.rel/is_same.pass.cpp b/test/std/utilities/meta/meta.rel/is_same.pass.cpp
index 634580550..739713bf4 100644
--- a/test/std/utilities/meta/meta.rel/is_same.pass.cpp
+++ b/test/std/utilities/meta/meta.rel/is_same.pass.cpp
@@ -56,7 +56,7 @@ public:
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_same<int, int>();
     test_is_same<void, void>();
@@ -69,4 +69,6 @@ int main()
     test_is_not_same<Class, int*>();
     test_is_not_same<int*, int&>();
     test_is_not_same<int&, int>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
index 62699fed4..a887d52bb 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
@@ -25,7 +25,7 @@ void test_remove_all_extents()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_all_extents<int, int> ();
     test_remove_all_extents<const Enum, const Enum> ();
@@ -39,4 +39,6 @@ int main()
     test_remove_all_extents<const int[2][3], const int> ();
     test_remove_all_extents<int[1][2][3], int> ();
     test_remove_all_extents<const int[1][2][3], const int> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
index 1c0f98848..a0b19d6a6 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
@@ -26,7 +26,7 @@ void test_remove_extent()
 }
 
 
-int main()
+int main(int, char**)
 {
     test_remove_extent<int, int> ();
     test_remove_extent<const Enum, const Enum> ();
@@ -40,4 +40,6 @@ int main()
     test_remove_extent<const int[2][3], const int[3]> ();
     test_remove_extent<int[1][2][3], int[2][3]> ();
     test_remove_extent<const int[1][2][3], const int[2][3]> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
index c7fb61232..edde65657 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
@@ -32,7 +32,7 @@ void test_add_const()
     test_add_const_imp<const volatile T, const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_add_const<void>();
     test_add_const<int>();
@@ -41,4 +41,6 @@ int main()
     test_add_const<const int&>();
     test_add_const<int*>();
     test_add_const<const int*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
index 0662c9dd4..5621bbf42 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
@@ -32,7 +32,7 @@ void test_add_cv()
     test_add_cv_imp<const volatile T, const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_add_cv<void>();
     test_add_cv<int>();
@@ -41,4 +41,6 @@ int main()
     test_add_cv<const int&>();
     test_add_cv<int*>();
     test_add_cv<const int*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
index 476a780a4..6dfaa60f8 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
@@ -32,7 +32,7 @@ void test_add_volatile()
     test_add_volatile_imp<const volatile T, const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_add_volatile<void>();
     test_add_volatile<int>();
@@ -41,4 +41,6 @@ int main()
     test_add_volatile<const int&>();
     test_add_volatile<int*>();
     test_add_volatile<const int*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
index d53d6f805..3c927e7c9 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
@@ -32,7 +32,7 @@ void test_remove_const()
     test_remove_const_imp<const volatile T, volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_const<void>();
     test_remove_const<int>();
@@ -41,4 +41,6 @@ int main()
     test_remove_const<const int&>();
     test_remove_const<int*>();
     test_remove_const<const int*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
index 569b9642d..2dc8d26e0 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
@@ -32,7 +32,7 @@ void test_remove_cv()
     test_remove_cv_imp<const volatile T, T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_cv<void>();
     test_remove_cv<int>();
@@ -41,4 +41,6 @@ int main()
     test_remove_cv<const int&>();
     test_remove_cv<int*>();
     test_remove_cv<const int*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
index 358d2fa8b..fb45d9439 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
@@ -32,7 +32,7 @@ void test_remove_volatile()
     test_remove_volatile_imp<const volatile T, const T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_volatile<void>();
     test_remove_volatile<int>();
@@ -41,4 +41,6 @@ int main()
     test_remove_volatile<const int&>();
     test_remove_volatile<int*>();
     test_remove_volatile<volatile int*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
index 08c0b8bb1..3e80402e8 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
@@ -17,7 +17,7 @@
 #include <cstddef>       // for std::max_align_t
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::aligned_storage<10, 1 >::type T1;
@@ -285,4 +285,6 @@ int main()
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
index 2564f1120..cf9fe632d 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
@@ -16,7 +16,9 @@
 
 class A; // Incomplete
 
-int main()
+int main(int, char**)
 {
     typedef std::aligned_union<10, A>::type T1;
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
index 800a0074c..789fd12a9 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::aligned_union<10, char >::type T1;
@@ -111,4 +111,6 @@ int main()
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 4, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
index 70d2ddf09..f96603b30 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
@@ -234,7 +234,7 @@ static_assert(is_same<typename result_of<PMD(const S*)>::type, const char&>::val
 } // namespace note_b_example
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::common_type<int>::type, int>::value), "");
     static_assert((std::is_same<std::common_type<char>::type, char>::value), "");
@@ -307,4 +307,6 @@ int main()
     static_assert((std::is_same<std::common_type<const int, int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<int, const int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<const int, const int>::type, int>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
index b408dfb2c..288376ac9 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
@@ -14,7 +14,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::conditional<true, char, int>::type, char>::value), "");
     static_assert((std::is_same<std::conditional<false, char, int>::type, int>::value), "");
@@ -22,4 +22,6 @@ int main()
     static_assert((std::is_same<std::conditional_t<true, char, int>, char>::value), "");
     static_assert((std::is_same<std::conditional_t<false, char, int>, int>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
index a6f85e921..94d972039 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
@@ -23,7 +23,7 @@ void test_decay()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_decay<void, void>();
     test_decay<int, int>();
@@ -38,4 +38,6 @@ int main()
     test_decay<int(int)  &, int(int)  &>();
     test_decay<int(int) &&, int(int) &&>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
index c7b0763e1..c033d1aef 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
@@ -12,7 +12,9 @@
 
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::enable_if<false>::type A;
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
index bb107d90a..c02c6efdb 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
@@ -14,7 +14,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::enable_if<true>::type, void>::value), "");
     static_assert((std::is_same<std::enable_if<true, int>::type, int>::value), "");
@@ -22,4 +22,6 @@ int main()
     static_assert((std::is_same<std::enable_if_t<true>, void>::value), "");
     static_assert((std::is_same<std::enable_if_t<true, int>, int>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
index 70aa3e212..79382d359 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
@@ -13,7 +13,9 @@
 
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::enable_if_t<false> A;
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
index e67cab8e4..e6a01a77a 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
@@ -23,7 +23,7 @@ void test_remove_cvref()
     static_assert((std::is_same<         std::remove_cvref_t<T>,     U>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_cvref<void, void>();
     test_remove_cvref<int, int>();
@@ -48,4 +48,6 @@ int main()
     test_remove_cvref<int(int) volatile, int(int) volatile>();
     test_remove_cvref<int(int)  &, int(int)  &>();
     test_remove_cvref<int(int) &&, int(int) &&>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
index 313691f32..34dd6d8ea 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
@@ -92,7 +92,7 @@ void test_no_result()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     typedef NotDerived ND;
     { // functor object
@@ -366,4 +366,6 @@ int main()
 #endif
     test_no_result<PMD(ND&)>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
index 55fef6a40..4c020d3da 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
@@ -55,7 +55,7 @@ void test_result_of_imp()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef char F::*PMD;
@@ -168,4 +168,6 @@ int main()
     test_result_of_imp<int (F::* (std::unique_ptr<const F> ))       () const, int>();
     }
     test_result_of_imp<decltype(&wat::foo)(wat), void>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
index 2946e17f5..7e90c3df9 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
@@ -22,7 +22,7 @@ void test_type_identity()
     static_assert((std::is_same<         std::type_identity_t<T>,     T>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test_type_identity<void>();
     test_type_identity<int>();
@@ -36,4 +36,6 @@ int main()
     test_type_identity<int(int) volatile>();
     test_type_identity<int(int)  &>();
     test_type_identity<int(int) &&>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
index ed1bdc44c..be1c739ee 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
@@ -27,7 +27,7 @@ enum E { V = INT_MIN };
 enum F { W = UINT_MAX };
 #endif // TEST_UNSIGNED_UNDERLYING_TYPE
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::underlying_type<E>::type, int>::value),
                   "E has the wrong underlying type");
@@ -52,4 +52,6 @@ int main()
     static_assert((std::is_same<std::underlying_type_t<G>, char>::value), "");
 #endif // TEST_STD_VER > 11
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
index ec4e270be..22c0b79d6 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
@@ -45,7 +45,7 @@ void test_function1()
 
 struct Foo {};
 
-int main()
+int main(int, char**)
 {
     test_add_pointer<void, void*>();
     test_add_pointer<int, int*>();
@@ -76,4 +76,6 @@ int main()
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
index 1f62b1412..ba7cceb29 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
@@ -22,7 +22,7 @@ void test_remove_pointer()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_pointer<void, void>();
     test_remove_pointer<int, int>();
@@ -40,4 +40,6 @@ int main()
     test_remove_pointer<int(*)[3], int[3]>();
     test_remove_pointer<int*&, int*&>();
     test_remove_pointer<const int*&, const int*&>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
index 68d8aef35..dadcafca6 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
@@ -44,7 +44,7 @@ void test_function1()
 
 struct Foo {};
 
-int main()
+int main(int, char**)
 {
     test_add_lvalue_reference<void, void>();
     test_add_lvalue_reference<int, int&>();
@@ -75,4 +75,6 @@ int main()
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
index c13a62366..34c6cd3dd 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
@@ -46,7 +46,7 @@ void test_function1()
 
 struct Foo {};
 
-int main()
+int main(int, char**)
 {
     test_add_rvalue_reference<void, void>();
     test_add_rvalue_reference<int, int&&>();
@@ -73,4 +73,6 @@ int main()
     test_function0<void (Foo::*)() &&>();
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
index 1cecd51e2..5612ba678 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
@@ -22,7 +22,7 @@ void test_remove_reference()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_reference<void, void>();
     test_remove_reference<int, int>();
@@ -43,4 +43,6 @@ int main()
     test_remove_reference<int*&&, int*>();
     test_remove_reference<const int*&&, const int*>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
index b962782d0..fa6ce8e3e 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
@@ -42,7 +42,7 @@ void test_make_signed()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_make_signed< signed char, signed char >();
     test_make_signed< unsigned char, signed char >();
@@ -66,4 +66,6 @@ int main()
     test_make_signed< HugeEnum, __int128_t >();
 # endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
index 606fdf426..cf5404f8c 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
@@ -42,7 +42,7 @@ void test_make_unsigned()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_make_unsigned<signed char, unsigned char> ();
     test_make_unsigned<unsigned char, unsigned char> ();
@@ -67,4 +67,6 @@ int main()
     test_make_unsigned<HugeEnum, __uint128_t>();
 # endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.type.synop/endian.pass.cpp b/test/std/utilities/meta/meta.type.synop/endian.pass.cpp
index 65ba30192..52924b357 100644
--- a/test/std/utilities/meta/meta.type.synop/endian.pass.cpp
+++ b/test/std/utilities/meta/meta.type.synop/endian.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
     static_assert(std::is_enum<std::endian>::value, "");
 
 // Check that E is a scoped enum by checking for conversions.
@@ -43,4 +43,6 @@ int main() {
 
     assert ((c[0] == 1) == (std::endian::native == std::endian::big));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
index 903098415..43cc5bfce 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
@@ -39,7 +39,7 @@ public:
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_alignment_of<int&, 4>();
     test_alignment_of<Class, 1>();
@@ -57,4 +57,6 @@ int main()
     test_alignment_of<bool, 1>();
 #endif
     test_alignment_of<unsigned, 4>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
index bfd36533e..927ce1373 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
@@ -50,7 +50,7 @@ public:
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_extent<void, 0>();
     test_extent<int&, 0>();
@@ -70,4 +70,6 @@ int main()
     test_extent1<int[2], 0>();
     test_extent1<int[2][4], 4>();
     test_extent1<int[][4], 4>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
index 74a3637a4..6c2eecb86 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
@@ -35,7 +35,7 @@ public:
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_rank<void, 0>();
     test_rank<int&, 0>();
@@ -50,4 +50,6 @@ int main()
     test_rank<char[3], 1>();
     test_rank<char[][3], 2>();
     test_rank<char[][4][3], 3>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
index af46f4726..652eddaa8 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
@@ -45,7 +45,7 @@ public:
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     static_assert( std::is_same<void, std::void_t<>>::value, "");
 
@@ -64,4 +64,6 @@ int main()
     test2<void *, int&>();
 
     static_assert( std::is_same<void, std::void_t<int, double const &, Class, volatile int[], void>>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp b/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
index 25b8d715a..90514eaae 100644
--- a/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
+++ b/test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
@@ -27,9 +27,11 @@
 # endif
 #endif
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_void_t)
   static_assert(std::is_same_v<std::void_t<int>, void>, "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
index 1e2dc42ae..9f3d8f558 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
@@ -48,7 +48,7 @@ typedef const char const_array[3];
 typedef char incomplete_array[];
 struct Incomplete;
 
-int main()
+int main(int, char**)
 {
     test_array<array>();
     test_array<const_array>();
@@ -57,4 +57,6 @@ int main()
 
 //  LWG#2582
     static_assert(!std::is_array<Incomplete>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
index 93bf9efb4..3dd696932 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
@@ -49,11 +49,13 @@ class Class
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_class<Class>();
     test_class<incomplete_type>();
 
 //  LWG#2582
     static_assert( std::is_class<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
index 95f71b68a..5fa849930 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
@@ -46,10 +46,12 @@ void test_enum()
 enum Enum {zero, one};
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_enum<Enum>();
 
 //  LWG#2582
     static_assert(!std::is_enum<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
index c4cf7153b..1f7556c7a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
@@ -45,7 +45,7 @@ void test_floating_point()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_floating_point<float>();
     test_floating_point<double>();
@@ -53,4 +53,6 @@ int main()
 
 //  LWG#2582
     static_assert(!std::is_floating_point<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
index 19ad3e92b..d7453be46 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
@@ -66,7 +66,7 @@ void test()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     TEST_REGULAR( void () );
     TEST_REGULAR( void (int) );
@@ -89,4 +89,6 @@ int main()
 
 //  LWG#2582
     static_assert(!std::is_function<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
index 74977e4b1..df66316b9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
@@ -45,7 +45,7 @@ void test_integral()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_integral<bool>();
     test_integral<char>();
@@ -67,4 +67,6 @@ int main()
 
 //  LWG#2582
     static_assert(!std::is_integral<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
index 8611daa15..320581991 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
@@ -70,7 +70,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_array<char[3]>();
     test_is_array<char[]>();
@@ -90,4 +90,6 @@ int main()
     test_is_not_array<bit_zero>();
     test_is_not_array<NotEmpty>();
     test_is_not_array<incomplete_type>();  //  LWG#2582
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
index 6eda248f7..def798b77 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
@@ -70,7 +70,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_class<Empty>();
     test_is_class<bit_zero>();
@@ -96,4 +96,6 @@ int main()
     test_is_not_class<Enum>();
     test_is_not_class<Union>();
     test_is_not_class<FunctionPtr>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
index 0261581f6..7d4b67fd8 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
@@ -70,7 +70,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_enum<Enum>();
 
@@ -91,4 +91,6 @@ int main()
     test_is_not_enum<Abstract>();
     test_is_not_enum<FunctionPtr>();
     test_is_not_enum<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
index 78e581a0c..e628451dc 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
@@ -70,7 +70,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_floating_point<float>();
     test_is_floating_point<double>();
@@ -99,4 +99,6 @@ int main()
     test_is_not_floating_point<Enum>();
     test_is_not_floating_point<FunctionPtr>();
     test_is_not_floating_point<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
index 0f2304fe7..b582499cb 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
@@ -74,7 +74,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_function<void(void)>();
     test_is_function<int(int)>();
@@ -105,4 +105,6 @@ int main()
   test_is_function<void() noexcept>();
   test_is_function<void() const && noexcept>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
index ede74445e..216df3b56 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
@@ -71,7 +71,7 @@ struct incomplete_type;
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_integral<short>();
     test_is_integral<unsigned short>();
@@ -105,4 +105,6 @@ int main()
     test_is_not_integral<NotEmpty>();
     test_is_not_integral<Abstract>();
     test_is_not_integral<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
index fe045a297..ed32cd9b9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
@@ -72,7 +72,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_lvalue_reference<int&>();
 
@@ -93,4 +93,6 @@ int main()
     test_is_not_lvalue_reference<NotEmpty>();
     test_is_not_lvalue_reference<Abstract>();
     test_is_not_lvalue_reference<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
index 7e20b58fc..95a8b5585 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
@@ -71,7 +71,7 @@ struct incomplete_type;
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_member_object_pointer<int Abstract::*>();
     test_is_member_object_pointer<double NotEmpty::*>();
@@ -95,4 +95,6 @@ int main()
     test_is_not_member_object_pointer<NotEmpty>();
     test_is_not_member_object_pointer<Abstract>();
     test_is_not_member_object_pointer<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
index 0a1b95354..cf46c7261 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
@@ -71,7 +71,7 @@ struct incomplete_type;
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_member_pointer<int Abstract::*>();
     test_is_member_pointer<double NotEmpty::*>();
@@ -102,4 +102,6 @@ int main()
   test_is_member_pointer<int (Empty::*)(int, long, long) const noexcept>();
   test_is_member_pointer<int (Empty::*)() & noexcept>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
index 762c21406..7ad765d8b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
@@ -72,7 +72,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_null_pointer<std::nullptr_t>();
 
@@ -93,4 +93,6 @@ int main()
     test_is_not_null_pointer<NotEmpty>();
     test_is_not_null_pointer<Abstract>();
     test_is_not_null_pointer<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
index 9fa33b93c..18609b812 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
@@ -70,7 +70,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_pointer<void*>();
     test_is_pointer<int*>();
@@ -92,4 +92,6 @@ int main()
     test_is_not_pointer<NotEmpty>();
     test_is_not_pointer<Abstract>();
     test_is_not_pointer<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
index 92e86713c..d17ed5fee 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
@@ -72,7 +72,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_rvalue_reference<int&&>();
 
@@ -93,4 +93,6 @@ int main()
     test_is_not_rvalue_reference<NotEmpty>();
     test_is_not_rvalue_reference<Abstract>();
     test_is_not_rvalue_reference<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
index 0fc3c4361..a86147a9a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
@@ -70,7 +70,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_union<Union>();
 
@@ -91,4 +91,6 @@ int main()
     test_is_not_union<NotEmpty>();
     test_is_not_union<Abstract>();
     test_is_not_union<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
index 0bfeaddee..ccbca9753 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
@@ -70,7 +70,7 @@ struct incomplete_type;
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_void<void>();
 
@@ -90,4 +90,6 @@ int main()
     test_is_not_void<Enum>();
     test_is_not_void<FunctionPtr>();
     test_is_not_void<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
index b4f010749..1c431edfa 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
@@ -37,11 +37,13 @@ void test_lvalue_ref()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_lvalue_ref<int&>();
     test_lvalue_ref<const int&>();
 
 //  LWG#2582
     static_assert(!std::is_lvalue_reference<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
index 345195e0e..fdbfd9039 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
@@ -52,7 +52,7 @@ class Class
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
   test_member_function_pointer<void (Class::*)()>();
   test_member_function_pointer<void (Class::*)(int)>();
@@ -225,4 +225,6 @@ int main()
 
 //  LWG#2582
   static_assert(!std::is_member_function_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
index 672a90a6f..916c580d5 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
@@ -51,7 +51,7 @@ class Class
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_member_function_pointer<void (Class::*)()>();
     test_member_function_pointer<void (Class::*)(int)>();
@@ -79,4 +79,6 @@ int main()
 
 //  LWG#2582
     static_assert(!std::is_member_function_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
index 2f77553fd..b22e59e37 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
@@ -49,10 +49,12 @@ class Class
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_member_object_pointer<int Class::*>();
 
 //  LWG#2582
     static_assert(!std::is_member_object_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
index 759eee668..993b32fdf 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
@@ -46,13 +46,16 @@ void test_nullptr()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_nullptr<std::nullptr_t>();
 
 //  LWG#2582
     static_assert(!std::is_null_pointer<incomplete_type>::value, "");
+    return 0;
 }
 #else
-int main() {}
+int main(int, char**) {
+  return 0;
+}
 #endif
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
index 68964f526..68f4186db 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
@@ -46,7 +46,7 @@ void test_pointer()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_pointer<void*>();
     test_pointer<int*>();
@@ -55,4 +55,6 @@ int main()
 
 //  LWG#2582
     static_assert(!std::is_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
index cf0b246c6..e40a2a014 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
@@ -38,11 +38,13 @@ void test_rvalue_ref()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_rvalue_ref<int&&>();
     test_rvalue_ref<const int&&>();
 
 //  LWG#2582
     static_assert(!std::is_rvalue_reference<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
index 683eed65a..a840f5bb2 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
@@ -51,10 +51,12 @@ union Union
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_union<Union>();
 
 //  LWG#2582
     static_assert(!std::is_union<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
index 047de2004..d9defa528 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
@@ -45,10 +45,12 @@ void test_void()
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_void<void>();
 
 //  LWG#2582
     static_assert(!std::is_void<incomplete_type>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
index b0ced4a9c..487e14446 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
@@ -39,10 +39,12 @@ typedef char incomplete_array[];
 
 class incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_array<array>();
     test_array<const_array>();
     test_array<incomplete_array>();
     test_array<incomplete_type[]>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
index bff535c9a..bc072198f 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
@@ -39,8 +39,10 @@ class Class
 
 class incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_class<Class>();
     test_class<incomplete_type>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
index 33807bc4d..71c74f2ba 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
@@ -35,7 +35,9 @@ void test_enum()
 
 enum Enum {zero, one};
 
-int main()
+int main(int, char**)
 {
     test_enum<Enum>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
index 1a1eaee32..957473c2a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
@@ -33,9 +33,11 @@ void test_floating_point()
     test_floating_point_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_floating_point<float>();
     test_floating_point<double>();
     test_floating_point<long double>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
index 193cf688f..c27b1237e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
@@ -33,10 +33,12 @@ void test_function()
     test_function_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_function<void ()>();
     test_function<void (int)>();
     test_function<int (double)>();
     test_function<int (double, char)>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
index d349b75f7..cac606a51 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
@@ -33,7 +33,7 @@ void test_integral()
     test_integral_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_integral<bool>();
     test_integral<char>();
@@ -52,4 +52,6 @@ int main()
     test_integral<__int128_t>();
     test_integral<__uint128_t>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
index ff0ff7a34..683e885e2 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
@@ -72,7 +72,7 @@ enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_arithmetic<short>();
     test_is_arithmetic<unsigned short>();
@@ -103,4 +103,6 @@ int main()
     test_is_not_arithmetic<bit_zero>();
     test_is_not_arithmetic<NotEmpty>();
     test_is_not_arithmetic<Abstract>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
index a0d03dd6e..4d789066d 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
@@ -72,7 +72,7 @@ enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_compound<char[3]>();
     test_is_compound<char[]>();
@@ -94,4 +94,6 @@ int main()
     test_is_not_compound<void>();
     test_is_not_compound<int>();
     test_is_not_compound<double>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
index 343b1291a..b1a383602 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
@@ -72,7 +72,7 @@ enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_fundamental<std::nullptr_t>();
     test_is_fundamental<void>();
@@ -111,4 +111,6 @@ int main()
     test_is_not_fundamental<Enum>();
     test_is_not_fundamental<NotEmpty>();
     test_is_not_fundamental<Abstract>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
index e5486f73e..82f0ae9aa 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
@@ -72,7 +72,7 @@ enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
 //  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2),
 //    std::nullptr_t, and cv-qualified versions of these types (3.9.3)
@@ -101,4 +101,6 @@ int main()
     test_is_not_member_pointer<int(int)>();
     test_is_not_member_pointer<Enum>();
     test_is_not_member_pointer<FunctionPtr>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
index 8ec4a6d0f..8a6f6d84c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
@@ -72,7 +72,7 @@ enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
 // An object type is a (possibly cv-qualified) type that is not a function type,
 // not a reference type, and not a void type.
@@ -99,4 +99,6 @@ int main()
     test_is_not_object<int&>();
     test_is_not_object<int&&>();
     test_is_not_object<int(int)>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
index a511daf35..bb8a2d62c 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
@@ -72,7 +72,7 @@ enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_reference<int&>();
 #if TEST_STD_VER >= 11
@@ -100,4 +100,6 @@ int main()
     test_is_not_reference<int Empty::*>();
     test_is_not_reference<void (Empty::*)(int)>();
 
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
index c20f1e8ef..804c6848e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
@@ -72,7 +72,7 @@ enum Enum {zero, one};
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
 //  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2),
 //    std::nullptr_t, and cv-qualified versions of these types (3.9.3)
@@ -110,4 +110,6 @@ int main()
     test_is_not_scalar<NotEmpty>();
     test_is_not_scalar<Abstract>();
     test_is_not_scalar<int(int)>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
index 0ce0423f6..44027dadb 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
@@ -24,8 +24,10 @@ void test_lvalue_ref()
     static_assert(!std::is_member_pointer<T>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test_lvalue_ref<int&>();
     test_lvalue_ref<const int&>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
index cc75ef966..fda2e8181 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
@@ -37,9 +37,11 @@ class Class
 {
 };
 
-int main()
+int main(int, char**)
 {
     test_member_function_pointer<void (Class::*)()>();
     test_member_function_pointer<void (Class::*)(int)>();
     test_member_function_pointer<void (Class::*)(int, char)>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
index ea1302742..3e8117b6a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
@@ -37,7 +37,9 @@ class Class
 {
 };
 
-int main()
+int main(int, char**)
 {
     test_member_object_pointer<int Class::*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
index 61ae96e5b..f5677b95b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
@@ -33,10 +33,12 @@ void test_pointer()
     test_pointer_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_pointer<void*>();
     test_pointer<int*>();
     test_pointer<const int*>();
     test_pointer<void (*)(int)>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
index 63180a008..341b94626 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
@@ -26,8 +26,10 @@ void test_rvalue_ref()
     static_assert(!std::is_member_pointer<T>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test_rvalue_ref<int&&>();
     test_rvalue_ref<const int&&>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
index d30354d1a..fb48a70f3 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
@@ -39,7 +39,9 @@ union Union
     double __;
 };
 
-int main()
+int main(int, char**)
 {
     test_union<Union>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
index 3559d7b83..657f72774 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
@@ -33,7 +33,9 @@ void test_void()
     test_void_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_void<void>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
index d778526b5..e6f70123b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
@@ -80,7 +80,7 @@ struct B
 };
 
 
-int main()
+int main(int, char**)
 {
     test_has_not_has_unique_object_representations<void>();
     test_has_not_has_unique_object_representations<Empty>();
@@ -102,4 +102,6 @@ int main()
     test_has_unique_object_representations<char[3]>();
     test_has_unique_object_representations<char[]>();
 
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
index 9ee9bf163..57c1027c3 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
@@ -70,7 +70,7 @@ struct A
     ~A();
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_virtual_destructor<void>();
     test_has_not_virtual_destructor<A>();
@@ -87,4 +87,6 @@ int main()
 
     test_has_virtual_destructor<Abstract>();
     test_has_virtual_destructor<NotEmpty>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
index cbc031790..ee6a12e4b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
@@ -72,7 +72,7 @@ struct AbstractTemplate {
 template <>
 struct AbstractTemplate<double> {};
 
-int main()
+int main(int, char**)
 {
     test_is_not_abstract<void>();
     test_is_not_abstract<int&>();
@@ -90,4 +90,6 @@ int main()
     test_is_abstract<Abstract>();
     test_is_abstract<AbstractTemplate<int> >();
     test_is_not_abstract<AbstractTemplate<double> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
index a8f19fd10..843231f46 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
@@ -56,7 +56,7 @@ private:
 struct Union { int x; void* y; };
 
 
-int main ()
+int main(int, char**)
 {
   {
     test_false<void>();
@@ -75,4 +75,6 @@ int main ()
     test_true<Aggregate[42][101]>();
     test_true<Union>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
index eb98ddb54..8e5e2cc6e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -58,7 +58,7 @@ struct E
 template <typename T>
 struct X { T t; };
 
-int main()
+int main(int, char**)
 {
     test_is_assignable<int&, int&> ();
     test_is_assignable<int&, int> ();
@@ -79,4 +79,6 @@ int main()
 
 //  pointer to incomplete template type
     test_is_assignable<X<D>*&, X<D>*> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
index fdbdfbd59..0af73cf7e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
@@ -30,7 +30,7 @@ void test_is_const()
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_const<void>();
     test_is_const<int>();
@@ -44,4 +44,6 @@ int main()
 
     static_assert(!std::is_const<int&>::value, "");
     static_assert(!std::is_const<const int&>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
index f78319aff..a5b723c0e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
@@ -147,7 +147,7 @@ static constexpr bool clang_disallows_valid_static_cast_bug =
 #endif
 
 
-int main()
+int main(int, char**)
 {
     typedef Base B;
     typedef Derived D;
@@ -301,4 +301,6 @@ int main()
     test_is_not_constructible<void() &&> ();
 #endif
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
index 24719bfb8..3f10907a4 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
@@ -63,7 +63,7 @@ struct C
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_copy_assignable<int> ();
     test_is_copy_assignable<int&> ();
@@ -81,4 +81,6 @@ int main()
 #endif
     test_is_not_copy_assignable<void> ();
     test_is_not_copy_assignable<C> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
index 457270a89..f64c40e86 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
@@ -70,7 +70,7 @@ struct C
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_copy_constructible<A>();
     test_is_copy_constructible<int&>();
@@ -91,4 +91,6 @@ int main()
 #if TEST_STD_VER >= 11
     test_is_not_copy_constructible<B>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
index aef79f7fa..ce2ec9561 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
@@ -81,7 +81,7 @@ class B
     B();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_default_constructible<A>();
     test_is_default_constructible<Union>();
@@ -122,4 +122,6 @@ int main()
     test_is_not_default_constructible<void() &&> ();
 #endif
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
index 8722b78fe..1a32efa42 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -97,7 +97,7 @@ struct DeletedVirtualPrivateDestructor   { private:   virtual ~DeletedVirtualPri
 #endif
 
 
-int main()
+int main(int, char**)
 {
     test_is_destructible<A>();
     test_is_destructible<int&>();
@@ -142,4 +142,6 @@ int main()
     test_is_not_destructible<NotEmpty>();
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
index 6dafb55a3..850af8b7a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
@@ -78,7 +78,7 @@ struct bit_one
     int :  1;
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_empty<void>();
     test_is_not_empty<int&>();
@@ -100,4 +100,6 @@ int main()
     test_is_empty<EmptyBase>();
     test_is_empty<StaticMember>();
     test_is_empty<bit_zero>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
index 61aed970e..4cded0f92 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
@@ -48,7 +48,7 @@ void test_is_not_final()
 #endif
 }
 
-int main ()
+int main(int, char**)
 {
     test_is_not_final<int>();
     test_is_not_final<int*>();
@@ -58,4 +58,6 @@ int main ()
     test_is_not_final<U1*>();
     test_is_final    <U2>();
     test_is_not_final<U2*>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
index 80bb49509..b86ff5a85 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
@@ -69,7 +69,7 @@ enum Enum {zero, one};
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     test_is_literal_type<std::nullptr_t>();
@@ -101,4 +101,6 @@ int main()
 
     test_is_not_literal_type<NotEmpty>();
     test_is_not_literal_type<Abstract>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
index edf825dd7..5a330c6d3 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
@@ -53,7 +53,7 @@ struct A
     A();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_move_assignable<int> ();
     test_is_move_assignable<A> ();
@@ -68,4 +68,6 @@ int main()
     test_is_not_move_assignable<int[3]> ();
 #endif
     test_is_not_move_assignable<void> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
index 3052d3925..06ca5c463 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
@@ -66,7 +66,7 @@ struct B
 #endif
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_move_constructible<char[3]>();
     test_is_not_move_constructible<char[]>();
@@ -84,4 +84,6 @@ int main()
     test_is_move_constructible<NotEmpty>();
     test_is_move_constructible<bit_zero>();
     test_is_move_constructible<B>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
index c0a22e3b7..be1f016a4 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
@@ -45,7 +45,7 @@ struct C
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_nothrow_assignable<int&, int&> ();
     test_is_nothrow_assignable<int&, int> ();
@@ -58,4 +58,6 @@ int main()
     test_is_not_nothrow_assignable<B, A> ();
     test_is_not_nothrow_assignable<A, B> ();
     test_is_not_nothrow_assignable<C, C&> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
index e9c256aca..0d171261a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
@@ -97,7 +97,7 @@ struct Tuple {
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     test_is_nothrow_constructible<int> ();
     test_is_nothrow_constructible<int, const int&> ();
@@ -114,4 +114,6 @@ int main()
     static_assert(!std::is_constructible<Tuple&, Empty>::value, "");
     test_is_not_nothrow_constructible<Tuple &, Empty> (); // See bug #19616.
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
index a3d2611c9..64895adf4 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
@@ -52,7 +52,7 @@ struct A
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_nothrow_assign<int&>();
     test_has_nothrow_assign<Union>();
@@ -68,4 +68,6 @@ int main()
     test_has_not_nothrow_assign<void>();
     test_has_not_nothrow_assign<A>();
 
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
index 4caaeca25..6b1708839 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
@@ -55,7 +55,7 @@ struct A
     A(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_nothrow_copy_constructor<void>();
     test_has_not_nothrow_copy_constructor<A>();
@@ -68,4 +68,6 @@ int main()
     test_is_nothrow_copy_constructible<int*>();
     test_is_nothrow_copy_constructible<const int*>();
     test_is_nothrow_copy_constructible<bit_zero>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
index 6e443b303..c30facc51 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
@@ -67,7 +67,7 @@ struct DThrows
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     test_has_not_nothrow_default_constructor<void>();
     test_has_not_nothrow_default_constructor<int&>();
@@ -84,4 +84,6 @@ int main()
     test_is_nothrow_default_constructible<const int*>();
     test_is_nothrow_default_constructible<char[3]>();
     test_is_nothrow_default_constructible<bit_zero>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
index f58a93ce2..817d696d1 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
@@ -79,7 +79,7 @@ class Abstract
 };
 
 
-int main()
+int main(int, char**)
 {
     test_is_not_nothrow_destructible<void>();
     test_is_not_nothrow_destructible<char[]>();
@@ -110,4 +110,6 @@ int main()
     test_is_not_nothrow_destructible<PureProtectedDestructor>();
     test_is_not_nothrow_destructible<PurePrivateDestructor>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
index cb446ef01..4bcbabbcc 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
@@ -52,7 +52,7 @@ struct A
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_nothrow_assign<int&>();
     test_has_nothrow_assign<Union>();
@@ -66,4 +66,6 @@ int main()
 
     test_has_not_nothrow_assign<void>();
     test_has_not_nothrow_assign<A>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
index ce002e820..ab9e0c6bb 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
@@ -55,7 +55,7 @@ struct A
     A(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_nothrow_move_constructor<void>();
     test_has_not_nothrow_move_constructor<A>();
@@ -68,4 +68,6 @@ int main()
     test_is_nothrow_move_constructible<int*>();
     test_is_nothrow_move_constructible<const int*>();
     test_is_nothrow_move_constructible<bit_zero>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
index c90f938c5..f554199c6 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
@@ -46,7 +46,7 @@ struct ThrowingMove {
 
 } // namespace MyNS
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -79,4 +79,6 @@ int main()
         static_assert(std::is_nothrow_swappable_v<int>, "");
         static_assert(!std::is_nothrow_swappable_v<void>, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
index 2121f75b0..fb4beac17 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
@@ -45,7 +45,7 @@ void swap(M&&, M&&) noexcept {}
 
 } // namespace MyNS
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -77,4 +77,6 @@ int main()
         static_assert(std::is_nothrow_swappable_with_v<int&, int&>, "");
         static_assert(!std::is_nothrow_swappable_with_v<int&&, int&&>, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
index f0dac244c..87fe6ebbe 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
@@ -49,7 +49,7 @@ public:
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_pod<void>();
     test_is_not_pod<int&>();
@@ -61,4 +61,6 @@ int main()
     test_is_pod<const int*>();
     test_is_pod<char[3]>();
     test_is_pod<char[]>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
index feb8f270e..8829fea6b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
@@ -72,7 +72,7 @@ class Final {
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     test_is_not_polymorphic<void>();
     test_is_not_polymorphic<int&>();
@@ -91,4 +91,6 @@ int main()
 
     test_is_polymorphic<NotEmpty>();
     test_is_polymorphic<Abstract>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
index 5e9042c79..4936cc788 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
@@ -51,7 +51,7 @@ public:
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_not_signed<void>();
     test_is_not_signed<int&>();
@@ -71,4 +71,6 @@ int main()
     test_is_signed<__int128_t>();
     test_is_not_signed<__uint128_t>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
index 10f23cca9..fb096c89a 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
@@ -50,11 +50,13 @@ struct pair
     T2 second;
 };
 
-int main()
+int main(int, char**)
 {
     test_is_standard_layout<int> ();
     test_is_standard_layout<int[3]> ();
     test_is_standard_layout<pair<int, double> > ();
 
     test_is_not_standard_layout<int&> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
index 3e0980bd5..5768a954d 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
@@ -63,7 +63,7 @@ void swap(T&, T&) {}
 
 } // end namespace MyNS2
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -94,4 +94,6 @@ int main()
         static_assert(std::is_swappable_v<int>, "");
         static_assert(!std::is_swappable_v<M>, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
index 5d21f3699..5931e7ce7 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     // Use a builtin type so we don't get ADL lookup.
     typedef double T[17][29];
@@ -39,4 +39,6 @@ int main()
        std::iter_swap(t1, t2);
        std::swap_ranges(t1, t1 + 17, t2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
index f11f93338..cd65d14ef 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
@@ -45,7 +45,7 @@ void swap(M&&, M&&) {}
 
 } // namespace MyNS
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -74,4 +74,6 @@ int main()
         static_assert(std::is_swappable_with_v<int&, int&>, "");
         static_assert(!std::is_swappable_with_v<D&, C&>, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
index 4350f1299..8bb1b7c9b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
@@ -51,7 +51,7 @@ public:
     B();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivial<int> ();
     test_is_trivial<A> ();
@@ -59,4 +59,6 @@ int main()
     test_is_not_trivial<int&> ();
     test_is_not_trivial<volatile int&> ();
     test_is_not_trivial<B> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
index a85f57a5e..124480c07 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
@@ -47,7 +47,7 @@ struct C
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivially_assignable<int&, int&> ();
     test_is_trivially_assignable<int&, int> ();
@@ -58,4 +58,6 @@ int main()
     test_is_not_trivially_assignable<B, A> ();
     test_is_not_trivially_assignable<A, B> ();
     test_is_not_trivially_assignable<C&, C&> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
index 78ae8cfa9..42d54bd7e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
@@ -65,7 +65,7 @@ struct A
     A(int, double);
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivially_constructible<int> ();
     test_is_trivially_constructible<int, const int&> ();
@@ -73,4 +73,6 @@ int main()
     test_is_not_trivially_constructible<A, int> ();
     test_is_not_trivially_constructible<A, int, double> ();
     test_is_not_trivially_constructible<A> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
index 853c8aa32..91fbf69f4 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
@@ -59,7 +59,7 @@ struct A
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_trivially_copy_assignable<int&>();
     test_has_trivially_copy_assignable<Union>();
@@ -76,4 +76,6 @@ int main()
     test_has_not_trivially_copy_assignable<Abstract>();
     test_has_not_trivially_copy_assignable<const Empty>();
 
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
index decd7ffea..5744d2ca0 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
@@ -65,7 +65,7 @@ struct A
     A(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_trivial_copy_constructor<void>();
     test_has_not_trivial_copy_constructor<A>();
@@ -80,4 +80,6 @@ int main()
     test_is_trivially_copy_constructible<int*>();
     test_is_trivially_copy_constructible<const int*>();
     test_is_trivially_copy_constructible<bit_zero>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
index 073ea681d..51ac0803e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
@@ -65,7 +65,7 @@ public:
     C();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivially_copyable<int> ();
     test_is_trivially_copyable<const int> ();
@@ -76,4 +76,6 @@ int main()
     test_is_not_trivially_copyable<int&> ();
     test_is_not_trivially_copyable<const A&> ();
     test_is_not_trivially_copyable<B> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
index 2f70ba606..03ac030a3 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
@@ -69,7 +69,7 @@ struct A
     A();
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_trivial_default_constructor<void>();
     test_has_not_trivial_default_constructor<int&>();
@@ -85,4 +85,6 @@ int main()
     test_is_trivially_default_constructible<const int*>();
     test_is_trivially_default_constructible<char[3]>();
     test_is_trivially_default_constructible<bit_zero>();
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
index 37ea513fc..e79e4926b 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
@@ -87,7 +87,7 @@ struct A
     ~A();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_trivially_destructible<void>();
     test_is_not_trivially_destructible<A>();
@@ -115,4 +115,6 @@ int main()
     test_is_not_trivially_destructible<PureProtectedDestructor>();
     test_is_not_trivially_destructible<PurePrivateDestructor>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
index c4aa7b7dc..0a91efdf0 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
@@ -59,7 +59,7 @@ struct A
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_trivial_assign<int&>();
     test_has_trivial_assign<Union>();
@@ -76,4 +76,6 @@ int main()
     test_has_not_trivial_assign<Abstract>();
     test_has_not_trivial_assign<const Empty>();
 
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
index 6f47ed6fd..78c10a132 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
@@ -75,7 +75,7 @@ struct MoveOnly2
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test_has_not_trivial_move_constructor<void>();
     test_has_not_trivial_move_constructor<A>();
@@ -94,4 +94,6 @@ int main()
     static_assert(!std::is_trivially_move_constructible<MoveOnly1>::value, "");
     static_assert( std::is_trivially_move_constructible<MoveOnly2>::value, "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
index 86e5611c7..bc70a43b9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
@@ -51,7 +51,7 @@ public:
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_not_unsigned<void>();
     test_is_not_unsigned<int&>();
@@ -71,4 +71,6 @@ int main()
     test_is_unsigned<__uint128_t>();
     test_is_not_unsigned<__int128_t>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
index 28cb29f3b..cb0fc3c6e 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
@@ -30,7 +30,7 @@ void test_is_volatile()
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_volatile<void>();
     test_is_volatile<int>();
@@ -44,4 +44,6 @@ int main()
 
     static_assert(!std::is_volatile<int&>::value, "");
     static_assert(!std::is_volatile<volatile int&>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/nothing_to_do.pass.cpp b/test/std/utilities/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/nothing_to_do.pass.cpp
+++ b/test/std/utilities/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
index cfae63963..9bcfa8e46 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
@@ -23,8 +23,10 @@
 #include <optional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     using std::bad_optional_access;
     bad_optional_access ex;
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
index 80f2372e4..ac7be93f7 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
@@ -23,10 +23,12 @@
 #include <optional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     using std::bad_optional_access;
 
     static_assert(std::is_base_of<std::exception, bad_optional_access>::value, "");
     static_assert(std::is_convertible<bad_optional_access*, std::exception*>::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
index dbf8a0564..4f7aedbcb 100644
--- a/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool operator==(const X& lhs, const X& rhs) {
   return lhs.i_ == rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@ int main() {
     static_assert(o1 == 42, "");
     static_assert(!(101 == o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
index 539e35fe0..373634f68 100644
--- a/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
@@ -24,7 +24,7 @@ struct X {
 
 constexpr bool operator>(const X& lhs, const X& rhs) { return lhs.i_ > rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@ int main() {
     static_assert(o1 > 11, "");
     static_assert(!(42 > o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
index c7bbbda85..5d4839734 100644
--- a/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool operator>=(const X& lhs, const X& rhs) {
   return lhs.i_ >= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -62,4 +62,6 @@ int main() {
     static_assert(o1 >= 42, "");
     static_assert(!(11 >= o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
index 73ed85643..a601939c5 100644
--- a/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool operator<=(const X& lhs, const X& rhs) {
   return lhs.i_ <= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -62,4 +62,6 @@ int main() {
     static_assert(o1 <= 42, "");
     static_assert(!(101 <= o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
index c0c111afd..732095590 100644
--- a/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
@@ -24,7 +24,7 @@ struct X {
 
 constexpr bool operator<(const X& lhs, const X& rhs) { return lhs.i_ < rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@ int main() {
     static_assert(o1 < 101, "");
     static_assert(!(42 < o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp b/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
index 949a03a8c..0d14f1e97 100644
--- a/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool operator!=(const X& lhs, const X& rhs) {
   return lhs.i_ != rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@ int main() {
     static_assert(o1 != 101, "");
     static_assert(!(42 != o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp b/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
index a842804f3..66ab089dc 100644
--- a/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
@@ -17,9 +17,11 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
 
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.hash/hash.pass.cpp b/test/std/utilities/optional/optional.hash/hash.pass.cpp
index 0f74557b7..aa89a51d8 100644
--- a/test/std/utilities/optional/optional.hash/hash.pass.cpp
+++ b/test/std/utilities/optional/optional.hash/hash.pass.cpp
@@ -30,7 +30,7 @@ struct hash<B> {
 
 }
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     const std::size_t nullopt_hash =
@@ -76,4 +76,6 @@ int main()
       test_hash_enabled_for_type<std::optional<B>>();
       test_hash_enabled_for_type<std::optional<const B>>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullops/equal.pass.cpp b/test/std/utilities/optional/optional.nullops/equal.pass.cpp
index 05413c1f1..589446220 100644
--- a/test/std/utilities/optional/optional.nullops/equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/equal.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@ int main()
     static_assert (noexcept(nullopt == o1), "");
     static_assert (noexcept(o1 == nullopt), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullops/greater.pass.cpp b/test/std/utilities/optional/optional.nullops/greater.pass.cpp
index 7bc764d01..59dc62fce 100644
--- a/test/std/utilities/optional/optional.nullops/greater.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/greater.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@ int main()
     static_assert (noexcept(nullopt > o1), "");
     static_assert (noexcept(o1 > nullopt), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp b/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
index 7c77a95a1..e23e8794f 100644
--- a/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@ int main()
     static_assert (noexcept(nullopt >= o1), "");
     static_assert (noexcept(o1 >= nullopt), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp b/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
index 1d3994e4a..96f0754e4 100644
--- a/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
@@ -15,7 +15,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -36,4 +36,6 @@ int main()
     static_assert (noexcept(nullopt <= o1), "");
     static_assert (noexcept(o1 <= nullopt), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullops/less_than.pass.cpp b/test/std/utilities/optional/optional.nullops/less_than.pass.cpp
index 3b313c946..872f3159a 100644
--- a/test/std/utilities/optional/optional.nullops/less_than.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/less_than.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@ int main()
     static_assert (noexcept(nullopt < o1), "");
     static_assert (noexcept(o1 < nullopt), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp b/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
index 9b3c41c1c..7eea0fa88 100644
--- a/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@ int main()
     static_assert (noexcept(nullopt != o1), "");
     static_assert (noexcept(o1 != nullopt), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
index 9cbbc8bd9..2a7822ebb 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
@@ -18,7 +18,9 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     std::nullopt_t n = {};
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
index f664433cb..c9d843e9c 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
@@ -29,11 +29,13 @@ constexpr bool test()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_empty_v<nullopt_t>);
     static_assert(!std::is_default_constructible_v<nullopt_t>);
 
     static_assert(std::is_same_v<const nullopt_t, decltype(nullopt)>);
     static_assert(test());
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
index e40af0823..8d2a8a00c 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
@@ -241,7 +241,7 @@ enum MyEnum { Zero, One, Two, Three, FortyTwo = 42 };
 
 using Fn = void(*)();
 
-int main()
+int main(int, char**)
 {
     test_sfinae();
     // Test with instrumented type
@@ -268,4 +268,6 @@ int main()
         assert(**opt == 3);
     }
     test_throws();
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
index a9a1c07d8..6ccaafa6d 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
@@ -196,7 +196,7 @@ void test_ambigious_assign() {
 }
 
 
-int main()
+int main(int, char**)
 {
     test_with_test_type();
     test_ambigious_assign();
@@ -250,4 +250,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
index 8a4540e18..5900e6046 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -48,7 +48,7 @@ constexpr bool assign_value(optional<Tp>&& lhs) {
     return lhs.has_value() && rhs.has_value() && *lhs == *rhs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using O = optional<int>;
@@ -102,4 +102,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
index cf09bb5dd..c5cebc542 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
@@ -208,7 +208,7 @@ void test_on_test_type() {
 
 
 
-int main()
+int main(int, char**)
 {
     {
         test_on_test_type<TestTypes::TestType>();
@@ -265,4 +265,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
index 9141bea11..446e9ae96 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
@@ -69,7 +69,7 @@ public:
 
 bool Z::dtor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         X x;
@@ -117,4 +117,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
index 0c36da93d..c862c5f0e 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -66,7 +66,7 @@ constexpr bool assign_value(optional<Tp>&& lhs) {
     return lhs.has_value() && rhs.has_value() && *lhs == Tp{101};
 }
 
-int main()
+int main(int, char**)
 {
     {
         static_assert(std::is_nothrow_move_assignable<optional<int>>::value, "");
@@ -204,4 +204,5 @@ int main()
         };
         static_assert(std::is_nothrow_move_assignable<optional<NoThrowMove>>::value, "");
     }
+    return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
index e6b67430f..af582d732 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
@@ -22,7 +22,7 @@ using std::optional;
 using std::nullopt_t;
 using std::nullopt;
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> opt;
@@ -63,4 +63,6 @@ int main()
     assert(TT::alive == 0);
     assert(TT::destroyed == 1);
     TT::reset();
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
index d043fd1de..cabaa070b 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
@@ -201,7 +201,7 @@ void test_ambigious_assign() {
 }
 
 
-int main()
+int main(int, char**)
 {
     test_with_test_type();
     test_ambigious_assign();
@@ -264,4 +264,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
index 861ab91d8..f91cd110f 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
@@ -153,7 +153,9 @@ void test_explicit() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
     test_implicit();
     test_explicit();
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
index 462811e51..1a7b36a5b 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
@@ -29,7 +29,7 @@
 
 using std::optional;
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -132,4 +132,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
index 4666d6d9b..b28d22330 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
@@ -78,7 +78,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef short U;
@@ -130,4 +130,6 @@ int main()
     }
 
     static_assert(!(std::is_constructible<optional<X>, const optional<Y>&>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 844abda00..e6793cd47 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -113,7 +113,7 @@ void test_reference_extension()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<int>(3);
@@ -169,4 +169,6 @@ int main()
         constexpr std::optional<int> o2 = o1;
         static_assert( *o2 == 4, "" );
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
index 943964241..7c6ae9bcd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -42,4 +42,6 @@ int main()
 //  optional(nullopt_t)
     std::optional opt(std::nullopt);   // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
index 973b49dff..fa2edfcdd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -50,4 +50,6 @@ int main()
     assert(static_cast<bool>(opt) == static_cast<bool>(source));
     assert(*opt == *source);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
index a00fa1706..3dd38da9d 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
@@ -61,7 +61,7 @@ test()
     };
 }
 
-int main()
+int main(int, char**)
 {
     test_constexpr<optional<int>>();
     test_constexpr<optional<int*>>();
@@ -77,4 +77,6 @@ int main()
     test_constexpr<optional<NonLiteralTypes::NoCtors&>>();
     test_constexpr<optional<NonLiteralTypes::NoCtors&&>>();
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
index 37adf8bbe..7741e0353 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
@@ -79,7 +79,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef X T;
@@ -117,4 +117,6 @@ int main()
         optional<U> rhs(3);
         test<T>(rhs, true);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
index ea4b7aa50..71febba35 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
@@ -62,7 +62,7 @@ public:
     explicit Z(int) { TEST_THROW(6); }
 };
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> rhs;
@@ -80,4 +80,6 @@ int main()
         optional<int> rhs(3);
         test<Z>(std::move(rhs), true);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
index 5cd23bad0..db995b4a7 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
@@ -58,7 +58,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         constexpr optional<int> opt(in_place, 5);
@@ -144,4 +144,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
index f62e6a3a8..c8c76df25 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
@@ -66,7 +66,7 @@ public:
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, "");
@@ -112,4 +112,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
index 622b8e428..a8634b961 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
@@ -28,9 +28,11 @@ struct S {
     };
 
 
-int main()
+int main(int, char**)
 {
     static_assert (!std::is_trivially_move_constructible_v<S>, "" );
     constexpr std::optional<S> o1;
     constexpr std::optional<S> o2 = std::move(o1);  // not constexpr
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index afba631bf..bf536ec63 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -151,7 +151,7 @@ void test_reference_extension()
 }
 
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<int>(3);
@@ -225,4 +225,6 @@ int main()
     constexpr std::optional<int> o2 = std::move(o1);
     static_assert( *o2 == 4, "" );
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
index 850ed6eca..927ac19ea 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
@@ -61,7 +61,7 @@ test()
     };
 }
 
-int main()
+int main(int, char**)
 {
     test_constexpr<optional<int>>();
     test_constexpr<optional<int*>>();
@@ -69,4 +69,6 @@ int main()
     test_constexpr<optional<NonTrivialTypes::NoCtors>>();
     test_constexpr<optional<NonConstexprTypes::NoCtors>>();
     test<optional<NonLiteralTypes::NoCtors>>();
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
index fd74f9ae1..fe4252b49 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
@@ -61,7 +61,7 @@ struct Z
     Z(int) { TEST_THROW(6); }
 };
 
-int main()
+int main(int, char**)
 {
     {
         optional<short> rhs;
@@ -89,4 +89,6 @@ int main()
     }
 
     static_assert(!(std::is_constructible<optional<X>, optional<Z>>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
index 5e9a216dc..7fd1f2fa1 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
@@ -39,7 +39,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -157,4 +157,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
index ca96586a1..23497bc4c 100644
--- a/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
@@ -32,7 +32,7 @@ public:
 
 bool X::dtor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@ int main()
         }
         assert(X::dtor_called == true);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
index e766db87e..704606c6f 100644
--- a/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
@@ -26,7 +26,7 @@ struct X
 
 bool X::dtor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> opt;
@@ -55,4 +55,6 @@ int main()
         assert(static_cast<bool>(opt) == false);
         X::dtor_called = false;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
index 29bf20bbd..7c008ef62 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     {
@@ -33,4 +33,6 @@ int main()
         constexpr optional<int> opt(0);
         static_assert(opt, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
index b109346f5..368f84155 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
@@ -43,7 +43,7 @@ test()
     return (*opt).test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
index 6663d8851..99a60e8dd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
@@ -36,7 +36,7 @@ struct Y
     int test() const {return 2;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -65,4 +65,6 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
index 02466d53b..ca494c5a8 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
@@ -36,7 +36,7 @@ struct Y
     int test() const && {return 2;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -65,4 +65,6 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
index 7dca9f613..f1b2ca393 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
@@ -43,7 +43,7 @@ test()
     return (*std::move(opt)).test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
index 59ce4c7e8..560fa8894 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     {
@@ -33,4 +33,6 @@ int main()
         constexpr optional<int> opt(0);
         static_assert(opt.has_value(), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
index ac0b9a527..8c6c09861 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
@@ -40,7 +40,7 @@ test()
     return opt->test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::optional<X> opt; ((void)opt);
@@ -68,4 +68,6 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
index fd7e683be..b9539828a 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
@@ -39,7 +39,7 @@ struct Z
     constexpr int test() const {return 1;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const std::optional<X> opt; ((void)opt);
@@ -72,4 +72,6 @@ int main()
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
index 04a4fcffd..23fd85ba5 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
@@ -52,7 +52,7 @@ test()
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -78,4 +78,6 @@ int main()
     }
 #endif
     static_assert(test() == 7, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
index ab6504dba..5e81f2fb1 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
@@ -23,10 +23,12 @@ struct X
     int test() {return 4;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         constexpr optional<X> opt;
         static_assert(opt.value().test() == 3, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
index dcc9306b1..54bdc1001 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
@@ -41,7 +41,7 @@ struct X
     int test() && {return 6;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
index 5e218d80e..b330bb8db 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
@@ -41,7 +41,7 @@ struct X
     int test() && {return 6;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@ int main()
         }
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
index 93ec45b0b..8f22f1c0d 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
@@ -67,7 +67,9 @@ constexpr int test()
     return 0;
 }
 
-int main()
+int main(int, char**)
 {
     static_assert(test() == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
index 0b4c7928f..736fe791a 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
@@ -35,7 +35,7 @@ struct X
         {return x.i_ == y.i_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         constexpr optional<X> opt(2);
@@ -73,4 +73,6 @@ int main()
         const optional<X> opt;
         assert(opt.value_or(Y(3)) == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
index 21f630e8c..06206a324 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
@@ -50,7 +50,7 @@ test()
     return std::move(opt).value().test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -76,4 +76,6 @@ int main()
     }
 #endif
     static_assert(test() == 7, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
index 7d79251e2..e881a0c62 100644
--- a/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
@@ -64,7 +64,7 @@ public:
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> opt1;
@@ -302,4 +302,6 @@ int main()
         assert(*opt2 == 2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
index 67e1b76d7..531173ade 100644
--- a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
@@ -21,7 +21,7 @@ private:
     ~X() {}
 };
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     {
@@ -46,4 +46,6 @@ int main()
     }
     // FIXME these are garbage diagnostics that Clang should not produce
     // expected-error@optional:* 0+ {{is not a base class}}
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/special_members.pass.cpp b/test/std/utilities/optional/optional.object/special_members.pass.cpp
index a315ed8ca..28783264d 100644
--- a/test/std/utilities/optional/optional.object/special_members.pass.cpp
+++ b/test/std/utilities/optional/optional.object/special_members.pass.cpp
@@ -52,11 +52,12 @@ struct DoTestsMetafunction {
     DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
 };
 
-int main() {
+int main(int, char**) {
     sink(
         ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
         ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
         NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
         NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{}
     );
+    return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/triviality.pass.cpp b/test/std/utilities/optional/optional.object/triviality.pass.cpp
index 7c82e17d6..f53d86000 100644
--- a/test/std/utilities/optional/optional.object/triviality.pass.cpp
+++ b/test/std/utilities/optional/optional.object/triviality.pass.cpp
@@ -85,7 +85,7 @@ struct TrivialCopyNonTrivialMove {
     TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
 };
 
-int main() {
+int main(int, char**) {
     sink(
         ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
         ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
@@ -93,4 +93,5 @@ int main() {
         NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
         DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
     );
+    return 0;
 }
diff --git a/test/std/utilities/optional/optional.object/types.pass.cpp b/test/std/utilities/optional/optional.object/types.pass.cpp
index cef295754..7c32d1857 100644
--- a/test/std/utilities/optional/optional.object/types.pass.cpp
+++ b/test/std/utilities/optional/optional.object/types.pass.cpp
@@ -28,10 +28,12 @@ test()
     static_assert(std::is_same<typename Opt::value_type, T>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test<optional<int>, int>();
     test<optional<const int>, const int>();
     test<optional<double>, double>();
     test<optional<const double>, const double>();
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.relops/equal.pass.cpp b/test/std/utilities/optional/optional.relops/equal.pass.cpp
index baeb16bb6..4fc85157a 100644
--- a/test/std/utilities/optional/optional.relops/equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/equal.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool operator==(const X& lhs, const X& rhs) {
   return lhs.i_ == rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -82,4 +82,6 @@ int main() {
     static_assert(o1 == O2(42), "");
     static_assert(!(O2(101) == o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp b/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
index 3a88640ca..4bc9720aa 100644
--- a/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
@@ -25,7 +25,7 @@ constexpr bool operator>=(const X& lhs, const X& rhs) {
   return lhs.i_ >= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -79,4 +79,6 @@ int main() {
     static_assert(o1 >= O2(42), "");
     static_assert(!(O2(1) >= o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.relops/greater_than.pass.cpp b/test/std/utilities/optional/optional.relops/greater_than.pass.cpp
index 7f7b24a75..d168cd706 100644
--- a/test/std/utilities/optional/optional.relops/greater_than.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/greater_than.pass.cpp
@@ -23,7 +23,7 @@ struct X {
 
 constexpr bool operator>(const X& lhs, const X& rhs) { return lhs.i_ > rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -77,4 +77,6 @@ int main() {
     static_assert(o1 > O2(1), "");
     static_assert(!(O2(42) > o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.relops/less_equal.pass.cpp b/test/std/utilities/optional/optional.relops/less_equal.pass.cpp
index e9180cb3e..835be64f8 100644
--- a/test/std/utilities/optional/optional.relops/less_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/less_equal.pass.cpp
@@ -25,7 +25,7 @@ constexpr bool operator<=(const X& lhs, const X& rhs) {
   return lhs.i_ <= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -79,4 +79,6 @@ int main() {
     static_assert(o1 <= O2(42), "");
     static_assert(!(O2(101) <= o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.relops/less_than.pass.cpp b/test/std/utilities/optional/optional.relops/less_than.pass.cpp
index 29fa36a3e..832de4b29 100644
--- a/test/std/utilities/optional/optional.relops/less_than.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/less_than.pass.cpp
@@ -23,7 +23,7 @@ struct X {
 
 constexpr bool operator<(const X& lhs, const X& rhs) { return lhs.i_ < rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -77,4 +77,6 @@ int main() {
     static_assert(o1 < O2(101), "");
     static_assert(!(O2(101) < o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.relops/not_equal.pass.cpp b/test/std/utilities/optional/optional.relops/not_equal.pass.cpp
index 9f690477e..ab00b7aab 100644
--- a/test/std/utilities/optional/optional.relops/not_equal.pass.cpp
+++ b/test/std/utilities/optional/optional.relops/not_equal.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool operator!=(const X& lhs, const X& rhs) {
   return lhs.i_ != rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -82,4 +82,6 @@ int main() {
     static_assert(o1 != O2(101), "");
     static_assert(!(O2(42) != o1), "");
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
index fef17e772..772528927 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::make_optional;
@@ -55,4 +55,6 @@ int main()
         assert(**opt == 3);
         assert(s == nullptr);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
index 675e90036..d3461542b 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
@@ -17,7 +17,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::make_optional;
@@ -41,4 +41,6 @@ int main()
         auto opt = make_optional<std::string>(4, 'X');
         assert(*opt == "XXXX");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
index 4a9040e50..40b20bed5 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
@@ -27,7 +27,7 @@ struct TestT {
       : x(*il.begin()), size(static_cast<int>(il.size())) {}
 };
 
-int main()
+int main(int, char**)
 {
     using std::make_optional;
     {
@@ -49,4 +49,6 @@ int main()
         auto opt = make_optional<std::string>({'a', 'b', 'c'}, std::allocator<char>{});
         assert(*opt == "abc");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.specalg/swap.pass.cpp b/test/std/utilities/optional/optional.specalg/swap.pass.cpp
index 3f37ac6e2..1a548e8cc 100644
--- a/test/std/utilities/optional/optional.specalg/swap.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/swap.pass.cpp
@@ -109,7 +109,7 @@ void test_swap_sfinae() {
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_swap_sfinae();
     {
@@ -348,4 +348,6 @@ int main()
         assert(*opt2 == 2);
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp b/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
index aca546d6c..b7d3b71e0 100644
--- a/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::in_place_t;
@@ -22,4 +22,6 @@ int main()
 
     optional<in_place_t> opt; // expected-note {{requested here}}
     // expected-error@optional:* {{"instantiation of optional with in_place_t is ill-formed"}}
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
index 28904aecf..daaad5664 100644
--- a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
@@ -13,10 +13,12 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
 
     std::initializer_list<int> list;
     (void)list;
+
+  return 0;
 }
diff --git a/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp b/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
index 4fe41b445..a4abbf027 100644
--- a/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -25,4 +25,6 @@ int main()
     optional<nullopt_t &> opt2; // expected-note 1 {{requested here}}
     optional<nullopt_t &&> opt3; // expected-note 1 {{requested here}}
     // expected-error@optional:* 4 {{instantiation of optional with nullopt_t is ill-formed}}
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
index d7f775eee..abf75631f 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<1, 1> R2;
     typedef std::ratio_add<R1, R2>::type R;
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
index ae43ac922..c62f75a0d 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -72,4 +72,6 @@ int main()
     typedef std::ratio_add<R1, R2>::type R;
     static_assert(R::num == 1 && R::den == 1, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
index ea96434b8..387f62903 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<1, 2> R2;
     typedef std::ratio_divide<R1, R2>::type R;
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
index 0b93e1a9c..ce7f69473 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -54,4 +54,6 @@ int main()
     typedef std::ratio_divide<R1, R2>::type R;
     static_assert(R::num == 630992477165LL && R::den == 127339199162436LL, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
index b884f4e2c..ef59bb39e 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<2, 1> R2;
     typedef std::ratio_multiply<R1, R2>::type R;
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
index 876158994..e20f23443 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -54,4 +54,6 @@ int main()
     typedef std::ratio_multiply<R1, R2>::type R;
     static_assert(R::num == 15519594064236LL && R::den == 5177331081415LL, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
index 95e9c8239..8b00462dc 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<-0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<1, 1> R2;
     typedef std::ratio_subtract<R1, R2>::type R;
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
index dbb948047..e3871f7a7 100644
--- a/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
+++ b/test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -72,4 +72,6 @@ int main()
     typedef std::ratio_subtract<R1, R2>::type R;
     static_assert(R::num == -1 && R::den == 1, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
index 9f547cdea..d0b1d5a17 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
@@ -21,7 +21,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@ int main()
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, false>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
index ab6deac86..dfb0e8fe8 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
@@ -21,7 +21,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@ int main()
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
index 79942fa6d..811706c58 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
@@ -21,7 +21,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@ int main()
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
index a80112ca4..45ba7cbf1 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
@@ -21,7 +21,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -93,4 +93,6 @@ int main()
     typedef std::ratio<641981, 1339063> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
index c5dbdedc8..ebb8624a8 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
@@ -21,7 +21,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@ int main()
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, false>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp b/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
index 68e6aba35..5000e73d3 100644
--- a/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
+++ b/test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
@@ -21,7 +21,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@ int main()
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp b/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
index bb3bb159b..336d7d8e5 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
@@ -18,7 +18,7 @@ void test()
     static_assert((std::ratio<N, D>::den == eD), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<1, 1, 1, 1>();
     test<1, 10, 1, 10>();
@@ -40,4 +40,6 @@ int main()
     test<-0x7FFFFFFFFFFFFFFFLL, 127, -72624976668147841LL, 1>();
     test<0x7FFFFFFFFFFFFFFFLL, -127, -72624976668147841LL, 1>();
     test<-0x7FFFFFFFFFFFFFFFLL, -127, 72624976668147841LL, 1>();
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp b/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
index 1c143f659..0841d858d 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
@@ -11,7 +11,9 @@
 #include <ratio>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     const std::intmax_t t1 = std::ratio<1, 0>::num;
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp b/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
index bf56271fb..f8bebc862 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
@@ -12,7 +12,9 @@
 #include <ratio>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     const std::intmax_t t1 = std::ratio<0x8000000000000000ULL, 1>::num;
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp b/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
index 6e44427f8..78310c6a2 100644
--- a/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
+++ b/test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
@@ -12,7 +12,9 @@
 #include <ratio>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     const std::intmax_t t1 = std::ratio<1, 0x8000000000000000ULL>::num;
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp b/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
+++ b/test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/ratio/typedefs.pass.cpp b/test/std/utilities/ratio/typedefs.pass.cpp
index 3f54f555a..8e24ff974 100644
--- a/test/std/utilities/ratio/typedefs.pass.cpp
+++ b/test/std/utilities/ratio/typedefs.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::atto::num == 1 && std::atto::den == 1000000000000000000ULL, "");
     static_assert(std::femto::num == 1 && std::femto::den == 1000000000000000ULL, "");
@@ -28,4 +28,6 @@ int main()
     static_assert(std::tera::num == 1000000000000ULL && std::tera::den == 1, "");
     static_assert(std::peta::num == 1000000000000000ULL && std::peta::den == 1, "");
     static_assert(std::exa::num == 1000000000000000000ULL && std::exa::den == 1, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp b/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
index cb7a5bbf6..f0ca5b0ea 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
@@ -54,7 +54,9 @@ void test_basic() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
index e11ec4b40..bc42afda3 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
@@ -107,7 +107,7 @@ void test_sfinae() {
 }
 
 
-int main() {
+int main(int, char**) {
   {
     test_basic</*IsArray*/ false>();
     test_sfinae<false>();
@@ -116,4 +116,6 @@ int main() {
     test_basic</*IsArray*/ true>();
     test_sfinae<true>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
index b89a45201..c9ebdf633 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
@@ -405,7 +405,7 @@ void test_deleter_value_category() {
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
@@ -416,4 +416,6 @@ int main() {
     test_noexcept<true>();
     test_deleter_value_category<true>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
index 0800f869f..ce9125465 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
@@ -114,7 +114,9 @@ void test_sfinae() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_sfinae();
   // FIXME: add tests
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
index 2b9bdb8c3..d5f46935a 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
@@ -113,7 +113,7 @@ void test_sfinae() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_sfinae();
   {
     std::unique_ptr<B> bptr(new B);
@@ -141,4 +141,6 @@ int main() {
   }
   assert(A::count == 0);
   assert(B::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
index 28ea9d7b0..ecba79dfd 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
@@ -32,7 +32,9 @@ void test_basic() {
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
index 91349cb30..5cd44b2f6 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
@@ -33,7 +33,9 @@ void test_basic() {
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
index e2fe7bb0d..577a906fb 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
@@ -61,7 +61,7 @@ void test_sfinae() {
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     B* p = new B;
     std::auto_ptr<B> ap(p);
@@ -93,4 +93,6 @@ int main() {
   }
 #endif
   test_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
index 3145c0c9f..1bd53b9a9 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
@@ -94,7 +94,7 @@ DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
   doIncompleteTypeTest<IncompleteType[], Deleter<IncompleteType[]> >(0);
 })
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae<int>();
     test_basic<int>();
@@ -103,4 +103,6 @@ int main() {
     test_sfinae<int[]>();
     test_basic<int[]>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
index f95897b9f..7c07b2ec9 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
@@ -159,7 +159,7 @@ void test_noexcept() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   {
     test_basic</*IsArray*/ false>();
     test_sfinae<int>();
@@ -170,4 +170,6 @@ int main() {
     test_sfinae<int[]>();
     test_noexcept<int[]>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
index f19943a46..3d0bb1cd1 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
@@ -204,7 +204,7 @@ void test_deleter_value_category() {
 }
 
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
@@ -215,4 +215,6 @@ int main() {
     test_noexcept<true>();
     test_deleter_value_category<true>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
index 010c2293a..bcf85b110 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
@@ -77,6 +77,8 @@ void test_sfinae() {
 }
 
 
-int main() {
+int main(int, char**) {
   test_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
index d269544c3..1dcf0cf32 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
@@ -157,7 +157,7 @@ void test_noexcept() {
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae();
     test_noexcept();
@@ -244,4 +244,6 @@ int main() {
     }
     checkNoneAlive();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
index e2694b38a..d24538832 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
@@ -61,7 +61,7 @@ void test_pointer_deleter_ctor() {
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     // test_pointer_ctor<int>();
     test_pointer_deleter_ctor<int>();
@@ -70,4 +70,6 @@ int main() {
     test_pointer_ctor<int[]>();
     test_pointer_deleter_ctor<int[]>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
index 8d3f94715..9ec7f7a4e 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
@@ -93,7 +93,7 @@ DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
   checkNumIncompleteTypeAlive(0);
 })
 
-int main() {
+int main(int, char**) {
   {
     test_basic<int>();
     test_sfinae<int>();
@@ -102,4 +102,6 @@ int main() {
     test_basic<int[]>();
     test_sfinae<int[]>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
index 55a5f48b2..48d41fc5c 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
@@ -156,7 +156,7 @@ DEFINE_AND_RUN_IS_INCOMPLETE_TEST({
   checkNumIncompleteTypeAlive(0);
 })
 
-int main() {
+int main(int, char**) {
   {
     test_pointer</*IsArray*/ false>();
     test_derived();
@@ -167,4 +167,6 @@ int main() {
     test_sfinae<int[]>();
     test_sfinae_runtime();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
index 4c5536d93..ccb4924d0 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
@@ -22,7 +22,9 @@ struct Deleter {
   void operator()(int* p) const { delete p; }
 };
 
-int main() {
+int main(int, char**) {
   // expected-error@+1 {{call to deleted constructor of 'std::unique_ptr<int, const Deleter &>}}
   std::unique_ptr<int, const Deleter&> s((int*)nullptr, Deleter());
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
index 246af44f9..59861effb 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
@@ -309,7 +309,7 @@ void test_nullptr() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   {
     test_basic</*IsArray*/ false>();
     test_nullptr<false>();
@@ -324,4 +324,6 @@ int main() {
     test_sfinae_runtime();
     test_noexcept<true>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
index e7b916558..9ef48b2e4 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
@@ -41,7 +41,9 @@ void test_basic() {
   assert(d.state() == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic<int>();
   test_basic<int[]>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
index cc2a8366e..f080165d5 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
@@ -49,7 +49,9 @@ void test_basic() {
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
index f271a7fb4..46569918a 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
@@ -102,7 +102,7 @@ void test_reset_no_arg() {
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   {
     test_reset_pointer</*IsArray*/ false>();
     test_reset_nullptr<false>();
@@ -113,4 +113,6 @@ int main() {
     test_reset_nullptr<true>();
     test_reset_no_arg<true>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
index 98a4125ba..7e3085a5b 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
@@ -17,7 +17,7 @@
 
 #include "unique_ptr_test_helper.h"
 
-int main() {
+int main(int, char**) {
   {
     std::unique_ptr<A[]> p;
     p.reset(static_cast<B*>(nullptr)); // expected-error {{no matching member function for call to 'reset'}}
@@ -26,4 +26,6 @@ int main() {
     std::unique_ptr<int[]> p;
     p.reset(static_cast<const int*>(nullptr)); // expected-error {{no matching member function for call to 'reset'}}
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
index e9d43b602..4f5a519b7 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "unique_ptr_test_helper.h"
 
-int main() {
+int main(int, char**) {
   {
     std::unique_ptr<A> p(new A);
     assert(A::count == 1);
@@ -42,4 +42,6 @@ int main() {
   }
   assert(A::count == 0);
   assert(B::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
index 129e3ea45..d5e15aafe 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
@@ -21,4 +21,6 @@ struct A {
   void reset() { ptr_.reset(); }
 };
 
-int main() { (new A)->reset(); }
+int main(int, char**) { (new A)->reset(); 
+  return 0;
+}
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
index 935ebab7f..35e997e30 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
@@ -81,7 +81,9 @@ void test_basic() {
   assert(TT::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
index 0fd37cbfa..8a5566b91 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
@@ -15,9 +15,11 @@
 #include <memory>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<int[]> p(new int(3));
   const std::unique_ptr<int[]>& cp = p;
   TEST_IGNORE_NODISCARD (*p);  // expected-error {{indirection requires pointer operand ('std::unique_ptr<int []>' invalid)}}
   TEST_IGNORE_NODISCARD (*cp); // expected-error {{indirection requires pointer operand ('const std::unique_ptr<int []>' invalid)}}
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
index 49cfccb6f..254d88bb6 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
@@ -15,7 +15,9 @@
 #include <memory>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<int> p(new int(3));
   assert(*p == 3);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
index ce45882a8..500821fb8 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
@@ -59,7 +59,9 @@ void test_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
index 76f2b4c67..1ff965f56 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
@@ -44,7 +44,9 @@ void test_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
index 31f33a265..e440a9599 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
@@ -58,7 +58,9 @@ void test_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
index 886fc95d9..4fa94f137 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
@@ -19,7 +19,7 @@ struct V {
   int member;
 };
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<V[]> p;
   std::unique_ptr<V[]> const& cp = p;
 
@@ -28,4 +28,6 @@ int main() {
 
   cp->member; // expected-error {{member reference type 'const std::unique_ptr<V []>' is not a pointer}}
               // expected-error@-1 {{no member named 'member'}}
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
index 0bc0c7718..f31ca6b28 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
@@ -21,7 +21,9 @@ struct A {
   A() : i_(7) {}
 };
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<A> p(new A);
   assert(p->i_ == 7);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
index 2b97f8fe5..21e7e6616 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
@@ -33,7 +33,7 @@ public:
 
 int A::next_ = 0;
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<A[]> p(new A[3]);
   assert(p[0] == 1);
   assert(p[1] == 2);
@@ -44,4 +44,6 @@ int main() {
   assert(p[0] == 3);
   assert(p[1] == 2);
   assert(p[2] == 1);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
index e5a960a6e..66286aa86 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
@@ -15,9 +15,11 @@
 #include <memory>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<int> p(new int[3]);
   std::unique_ptr<int> const& cp = p;
   p[0];  // expected-error {{type 'std::unique_ptr<int>' does not provide a subscript operator}}
   cp[1]; // expected-error {{type 'const std::unique_ptr<int>' does not provide a subscript operator}}
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
index a77194ecf..715335eb1 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
@@ -21,7 +21,7 @@ private:
     int val_;
     };
 
-int main()
+int main(int, char**)
 {
     {
     auto p1 = std::make_unique<int[]>(5);
@@ -40,4 +40,6 @@ int main()
     for ( int i = 0; i < 7; ++i )
         assert ( p3[i].get () == 3 );
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
index a0e256fcf..56adccf17 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up1 = std::make_unique<std::string[]>("error"); // doesn't compile - no bound
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
index 0f366c6c3..fda45ab89 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up2 = std::make_unique<int[]>(10, 20, 30, 40);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
index 90622fed1..9fa05c79d 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up3 = std::make_unique<int[5]>();    // this is deleted
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
index 5c10ac6bb..d98f052b5 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up4 = std::make_unique<int[5]>(11, 22, 33, 44, 55); // deleted
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
index 4adf2e9ae..08062c122 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
@@ -11,7 +11,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     std::unique_ptr<int> p1 = std::make_unique<int>(1);
@@ -28,4 +28,6 @@ int main()
     p2 = std::make_unique<std::string> ( 6, 'z' );
     assert ( *p2 == "zzzzzz" );
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
index 85605a2fc..6b8407c57 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
@@ -34,7 +34,7 @@ struct B
 
 int B::count = 0;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<B> d2;
     std::default_delete<A> d1 = d2;
@@ -44,4 +44,6 @@ int main()
     d1(p);
     assert(A::count == 0);
     assert(B::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
index c0a10e5e3..e7cbeaba5 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
@@ -23,11 +23,13 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A> d;
     A* p = new A;
     assert(A::count == 1);
     d(p);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
index b09640215..75f02d7c6 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
@@ -17,9 +17,11 @@
 
 struct A;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A> d;
     A* p = 0;
     d(p);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
index d03468c03..3bffeb576 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
@@ -15,9 +15,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::default_delete<const void> d;
     const void* p = 0;
     d(p);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
index 699d20ed4..4a2bb5f7d 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
@@ -24,8 +24,10 @@ struct B
 {
 };
 
-int main()
+int main(int, char**)
 {
     std::default_delete<B[]> d2;
     std::default_delete<A[]> d1 = d2;
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
index c2bfd31de..14e210598 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
@@ -19,9 +19,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::default_delete<int[]> d1;
     std::default_delete<const int[]> d2 = d1;
     ((void)d2);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
index 246cf9d8d..9b220462b 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
@@ -25,11 +25,13 @@ struct A
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A[]> d;
     A* p = new A[3];
     assert(A::count == 3);
     d(p);
     assert(A::count == 0);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
index 48ac04552..54fe0fcf7 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
@@ -17,9 +17,11 @@
 
 struct A;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A[]> d;
     A* p = 0;
     d(p);
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
index 774bc62d2..52c399e64 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
@@ -40,7 +40,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     const std::unique_ptr<int> p1(new int(1));
     assert(!(p1 == nullptr));
@@ -65,4 +65,6 @@ int main()
     assert(!(nullptr > p2));
     assert( (p2 >= nullptr));
     assert( (nullptr >= p2));
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
index e1f3e762d..ce83b5750 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
@@ -44,7 +44,7 @@ struct B
 
 int B::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const std::unique_ptr<A, Deleter<A> > p1(new A);
@@ -82,4 +82,6 @@ int main()
     assert(p1 == p2);
     assert(!(p1 != p2));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
index 167dd7826..5fad4beb6 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
@@ -52,7 +52,7 @@ struct B
 
 int B::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const std::unique_ptr<A, Deleter<A> > p1(new A);
@@ -96,4 +96,6 @@ int main()
     assert((p1 < p2) == !(p1 <= p2));
     assert((p1 < p2) == !(p1 >= p2));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
index 67cb170e4..4e45bbaef 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
@@ -44,7 +44,7 @@ private:
 
 };
 
-int main()
+int main(int, char**)
 {
     {
     A* p1 = new A(1);
@@ -98,4 +98,6 @@ int main()
         std::swap(p, p2);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
index 821929652..ee6405bde 100644
--- a/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
@@ -46,7 +46,7 @@ void test_char_pointer_ctor()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_char_pointer_ctor<0>();
     test_char_pointer_ctor<1>();
@@ -57,4 +57,6 @@ int main()
     test_char_pointer_ctor<64>();
     test_char_pointer_ctor<65>();
     test_char_pointer_ctor<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
index 0c88ba36a..bb5de6b18 100644
--- a/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
@@ -35,7 +35,7 @@ void test_default_ctor()
 }
 
 
-int main()
+int main(int, char**)
 {
     test_default_ctor<0>();
     test_default_ctor<1>();
@@ -46,4 +46,6 @@ int main()
     test_default_ctor<64>();
     test_default_ctor<65>();
     test_default_ctor<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
index f5052b5ef..453db91f2 100644
--- a/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
@@ -74,7 +74,7 @@ void test_string_ctor()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_string_ctor<0>();
     test_string_ctor<1>();
@@ -85,4 +85,6 @@ int main()
     test_string_ctor<64>();
     test_string_ctor<65>();
     test_string_ctor<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp b/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
index a09ce57e3..4697d8bd3 100644
--- a/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
@@ -39,7 +39,7 @@ void test_val_ctor()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_val_ctor<0>();
     test_val_ctor<1>();
@@ -50,4 +50,6 @@ int main()
     test_val_ctor<64>();
     test_val_ctor<65>();
     test_val_ctor<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp b/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
index 95347a2bc..dfac9d94a 100644
--- a/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
@@ -38,10 +38,12 @@ test()
     ((void)result); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<0>();
     test<10>();
     test<100>();
     test<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp b/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
index 05d286f90..a499b66fd 100644
--- a/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::bitset<0> >();
@@ -25,4 +25,6 @@ int main() {
     test_hash_enabled_for_type<std::bitset<1024> >();
     test_hash_enabled_for_type<std::bitset<100000> >();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/all.pass.cpp
index 4ac3bae75..fe9e0e0a3 100644
--- a/test/std/utilities/template.bitset/bitset.members/all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/all.pass.cpp
@@ -28,7 +28,7 @@ void test_all()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_all<0>();
     test_all<1>();
@@ -39,4 +39,6 @@ int main()
     test_all<64>();
     test_all<65>();
     test_all<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/any.pass.cpp b/test/std/utilities/template.bitset/bitset.members/any.pass.cpp
index 0483a04ff..95b640178 100644
--- a/test/std/utilities/template.bitset/bitset.members/any.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/any.pass.cpp
@@ -31,7 +31,7 @@ void test_any()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_any<0>();
     test_any<1>();
@@ -42,4 +42,6 @@ int main()
     test_any<64>();
     test_any<65>();
     test_any<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/count.pass.cpp b/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
index 9b66e93e2..5b04666bc 100644
--- a/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/count.pass.cpp
@@ -42,7 +42,7 @@ void test_count()
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     test_count<0>();
     test_count<1>();
@@ -53,4 +53,6 @@ int main()
     test_count<64>();
     test_count<65>();
     test_count<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
index b3f515c0c..14bd9eadf 100644
--- a/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
@@ -40,7 +40,7 @@ void test_flip_all()
         assert(v2[i] == ~v1[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_flip_all<0>();
     test_flip_all<1>();
@@ -51,4 +51,6 @@ int main()
     test_flip_all<64>();
     test_flip_all<65>();
     test_flip_all<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
index 96569e565..235b7e1a7 100644
--- a/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
@@ -58,7 +58,7 @@ void test_flip_one(bool test_throws)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_flip_one<0>(true);
     test_flip_one<1>(true);
@@ -69,4 +69,6 @@ int main()
     test_flip_one<64>(false);
     test_flip_one<65>(false);
     test_flip_one<1000>(false);
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/index.pass.cpp b/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
index fb68df5aa..a6eea1450 100644
--- a/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/index.pass.cpp
@@ -60,7 +60,7 @@ void test_index_const()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_index_const<0>();
     test_index_const<1>();
@@ -71,4 +71,6 @@ int main()
     test_index_const<64>();
     test_index_const<65>();
     test_index_const<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp b/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
index 54a1a31c0..9c6e28a88 100644
--- a/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
@@ -42,7 +42,7 @@ void test_index_const()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_index_const<0>();
     test_index_const<1>();
@@ -53,4 +53,6 @@ int main()
     test_index_const<64>();
     test_index_const<65>();
     test_index_const<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp b/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
index 27a20b4f6..59a7954a0 100644
--- a/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
@@ -41,7 +41,7 @@ void test_left_shift()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_left_shift<0>();
     test_left_shift<1>();
@@ -52,4 +52,6 @@ int main()
     test_left_shift<64>();
     test_left_shift<65>();
     test_left_shift<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
index c3becacd3..ad307ae82 100644
--- a/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
@@ -46,7 +46,7 @@ void test_left_shift()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_left_shift<0>();
     test_left_shift<1>();
@@ -57,4 +57,6 @@ int main()
     test_left_shift<64>();
     test_left_shift<65>();
     test_left_shift<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/none.pass.cpp b/test/std/utilities/template.bitset/bitset.members/none.pass.cpp
index d5004fbb6..2588ac60f 100644
--- a/test/std/utilities/template.bitset/bitset.members/none.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/none.pass.cpp
@@ -31,7 +31,7 @@ void test_none()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_none<0>();
     test_none<1>();
@@ -42,4 +42,6 @@ int main()
     test_none<64>();
     test_none<65>();
     test_none<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
index 87c3efd1f..17b2d4293 100644
--- a/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
@@ -39,7 +39,7 @@ void test_not_all()
         assert(v2[i] == ~v1[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_not_all<0>();
     test_not_all<1>();
@@ -50,4 +50,6 @@ int main()
     test_not_all<64>();
     test_not_all<65>();
     test_not_all<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
index 38564bba5..8560be246 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
@@ -41,7 +41,7 @@ void test_op_and_eq()
         assert(v1[i] == (v3[i] && v2[i]));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_and_eq<0>();
     test_op_and_eq<1>();
@@ -52,4 +52,6 @@ int main()
     test_op_and_eq<64>();
     test_op_and_eq<65>();
     test_op_and_eq<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
index 7c428bce0..d2363023e 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
@@ -48,7 +48,7 @@ void test_equality()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_equality<0>();
     test_equality<1>();
@@ -59,4 +59,6 @@ int main()
     test_equality<64>();
     test_equality<65>();
     test_equality<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
index f96c77bc2..42d525e5b 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
@@ -41,7 +41,7 @@ void test_op_or_eq()
         assert(v1[i] == (v3[i] || v2[i]));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_or_eq<0>();
     test_op_or_eq<1>();
@@ -52,4 +52,6 @@ int main()
     test_op_or_eq<64>();
     test_op_or_eq<65>();
     test_op_or_eq<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
index 647c5c028..44d58d8a1 100644
--- a/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
@@ -41,7 +41,7 @@ void test_op_xor_eq()
         assert(v1[i] == (v3[i] != v2[i]));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_xor_eq<0>();
     test_op_xor_eq<1>();
@@ -52,4 +52,6 @@ int main()
     test_op_xor_eq<64>();
     test_op_xor_eq<65>();
     test_op_xor_eq<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
index ae43bd7e9..91041176d 100644
--- a/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
@@ -29,7 +29,7 @@ void test_reset_all()
         assert(!v[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_reset_all<0>();
     test_reset_all<1>();
@@ -40,4 +40,6 @@ int main()
     test_reset_all<64>();
     test_reset_all<65>();
     test_reset_all<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
index ec92f6656..1abb4914b 100644
--- a/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
@@ -43,7 +43,7 @@ void test_reset_one(bool test_throws)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_reset_one<0>(true);
     test_reset_one<1>(true);
@@ -54,4 +54,6 @@ int main()
     test_reset_one<64>(false);
     test_reset_one<65>(false);
     test_reset_one<1000>(false);
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp b/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
index a94f9bf09..e05c3316b 100644
--- a/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
@@ -41,7 +41,7 @@ void test_right_shift()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_right_shift<0>();
     test_right_shift<1>();
@@ -52,4 +52,6 @@ int main()
     test_right_shift<64>();
     test_right_shift<65>();
     test_right_shift<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp b/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
index 387f68249..f23fbeebc 100644
--- a/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
@@ -46,7 +46,7 @@ void test_right_shift()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_right_shift<0>();
     test_right_shift<1>();
@@ -57,4 +57,6 @@ int main()
     test_right_shift<64>();
     test_right_shift<65>();
     test_right_shift<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp b/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
index 68f8c58bb..ca4708cc4 100644
--- a/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
@@ -28,7 +28,7 @@ void test_set_all()
         assert(v[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_set_all<0>();
     test_set_all<1>();
@@ -39,4 +39,6 @@ int main()
     test_set_all<64>();
     test_set_all<65>();
     test_set_all<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp b/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
index f660a4409..f723eebe0 100644
--- a/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
@@ -52,7 +52,7 @@ void test_set_one(bool test_throws)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_set_one<0>(true);
     test_set_one<1>(true);
@@ -63,4 +63,6 @@ int main()
     test_set_one<64>(false);
     test_set_one<65>(false);
     test_set_one<1000>(false);
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/size.pass.cpp b/test/std/utilities/template.bitset/bitset.members/size.pass.cpp
index f1719ab2e..41318d99e 100644
--- a/test/std/utilities/template.bitset/bitset.members/size.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/size.pass.cpp
@@ -18,7 +18,7 @@ void test_size()
     assert(v.size() == N);
 }
 
-int main()
+int main(int, char**)
 {
     test_size<0>();
     test_size<1>();
@@ -29,4 +29,6 @@ int main()
     test_size<64>();
     test_size<65>();
     test_size<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/test.pass.cpp b/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
index df3ee16be..5d566f5d0 100644
--- a/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/test.pass.cpp
@@ -53,7 +53,7 @@ void test_test(bool test_throws)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_test<0>(true);
     test_test<1>(true);
@@ -64,4 +64,6 @@ int main()
     test_test<64>(false);
     test_test<65>(false);
     test_test<1000>(false);
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
index d89794472..3897e1037 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
@@ -153,7 +153,7 @@ void test_to_string()
 }
 }
 
-int main()
+int main(int, char**)
 {
     test_to_string<0>();
     test_to_string<1>();
@@ -164,4 +164,6 @@ int main()
     test_to_string<64>();
     test_to_string<65>();
     test_to_string<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
index 1ea9b0f81..c43ef90ae 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
@@ -44,7 +44,7 @@ void test_to_ullong()
     }
 }
 
-int main()
+int main(int, char**)
 {
 //     test_to_ullong<0>();
     test_to_ullong<1>();
@@ -55,4 +55,6 @@ int main()
     test_to_ullong<64>();
     test_to_ullong<65>();
     test_to_ullong<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
index 71910f322..c6cf6b19a 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
@@ -46,7 +46,7 @@ void test_to_ulong()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_to_ulong<0>();
     test_to_ulong<1>();
@@ -57,4 +57,6 @@ int main()
     test_to_ulong<64>();
     test_to_ulong<65>();
     test_to_ulong<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
index af69d3951..21d5d0805 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
@@ -39,7 +39,7 @@ void test_op_and()
     assert((v1 & v2) == (v3 &= v2));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_and<0>();
     test_op_and<1>();
@@ -50,4 +50,6 @@ int main()
     test_op_and<64>();
     test_op_and<65>();
     test_op_and<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
index 8d9b2bdfb..4a71385a9 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
@@ -39,7 +39,7 @@ void test_op_not()
     assert((v1 ^ v2) == (v3 ^= v2));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_not<0>();
     test_op_not<1>();
@@ -50,4 +50,6 @@ int main()
     test_op_not<64>();
     test_op_not<65>();
     test_op_not<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
index c2cada15e..bc4847c19 100644
--- a/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
@@ -39,7 +39,7 @@ void test_op_or()
     assert((v1 | v2) == (v3 |= v2));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_or<0>();
     test_op_or<1>();
@@ -50,4 +50,6 @@ int main()
     test_op_or<64>();
     test_op_or<65>();
     test_op_or<1000>();
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
index 714fcd3ed..9abe19c7c 100644
--- a/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream in("01011010");
     std::bitset<8> b;
     in >> b;
     assert(b.to_ulong() == 0x5A);
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp b/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
index 06a36604a..2c4ce1e48 100644
--- a/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream os;
     std::bitset<8> b(0x5A);
     os << b;
     assert(os.str() == "01011010");
+
+  return 0;
 }
diff --git a/test/std/utilities/template.bitset/includes.pass.cpp b/test/std/utilities/template.bitset/includes.pass.cpp
index c98b150e7..90695ed3d 100644
--- a/test/std/utilities/template.bitset/includes.pass.cpp
+++ b/test/std/utilities/template.bitset/includes.pass.cpp
@@ -12,7 +12,7 @@
 
 template <class> void test_typedef() {}
 
-int main()
+int main(int, char**)
 {
   { // test for <string>
     std::string s; ((void)s);
@@ -24,4 +24,6 @@ int main()
     test_typedef<std::ostream>();
     test_typedef<std::iostream>();
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/date.time/ctime.pass.cpp b/test/std/utilities/time/date.time/ctime.pass.cpp
index 3fa04b779..ac29fd781 100644
--- a/test/std/utilities/time/date.time/ctime.pass.cpp
+++ b/test/std/utilities/time/date.time/ctime.pass.cpp
@@ -29,7 +29,7 @@
 #pragma GCC diagnostic ignored "-Wformat-zero-length"
 #endif
 
-int main()
+int main(int, char**)
 {
     std::clock_t c = 0;
     std::size_t s = 0;
@@ -60,4 +60,6 @@ int main()
     static_assert((std::is_same<decltype(std::localtime(&t)), std::tm*>::value), "");
 #endif
     static_assert((std::is_same<decltype(std::strftime(str,s,"",&tm)), std::size_t>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/days.pass.cpp b/test/std/utilities/time/days.pass.cpp
index a22f97b8f..43b53ea33 100644
--- a/test/std/utilities/time/days.pass.cpp
+++ b/test/std/utilities/time/days.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::days D;
     typedef D::rep Rep;
@@ -24,4 +24,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 25, "");
     static_assert(std::is_same_v<Period, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/hours.pass.cpp b/test/std/utilities/time/hours.pass.cpp
index e04888f2e..97fc2621b 100644
--- a/test/std/utilities/time/hours.pass.cpp
+++ b/test/std/utilities/time/hours.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::hours D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 22, "");
     static_assert((std::is_same<Period, std::ratio<3600> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/microseconds.pass.cpp b/test/std/utilities/time/microseconds.pass.cpp
index 20e12a9a2..ded1c22fe 100644
--- a/test/std/utilities/time/microseconds.pass.cpp
+++ b/test/std/utilities/time/microseconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::microseconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 54, "");
     static_assert((std::is_same<Period, std::micro>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/milliseconds.pass.cpp b/test/std/utilities/time/milliseconds.pass.cpp
index 6183b929f..b1fe99e12 100644
--- a/test/std/utilities/time/milliseconds.pass.cpp
+++ b/test/std/utilities/time/milliseconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::milliseconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 44, "");
     static_assert((std::is_same<Period, std::milli>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/minutes.pass.cpp b/test/std/utilities/time/minutes.pass.cpp
index 413d8cd6f..23f0bf287 100644
--- a/test/std/utilities/time/minutes.pass.cpp
+++ b/test/std/utilities/time/minutes.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::minutes D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 28, "");
     static_assert((std::is_same<Period, std::ratio<60> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/months.pass.cpp b/test/std/utilities/time/months.pass.cpp
index ff40823f1..b14b2fab5 100644
--- a/test/std/utilities/time/months.pass.cpp
+++ b/test/std/utilities/time/months.pass.cpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::months D;
     typedef D::rep Rep;
@@ -25,4 +25,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 20, "");
     static_assert(std::is_same_v<Period, std::ratio_divide<std::chrono::years::period, std::ratio<12>>>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/nanoseconds.pass.cpp b/test/std/utilities/time/nanoseconds.pass.cpp
index c14389da7..d58a375c2 100644
--- a/test/std/utilities/time/nanoseconds.pass.cpp
+++ b/test/std/utilities/time/nanoseconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::nanoseconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 63, "");
     static_assert((std::is_same<Period, std::nano>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/seconds.pass.cpp b/test/std/utilities/time/seconds.pass.cpp
index bd2d6d2b3..45a3f1d8e 100644
--- a/test/std/utilities/time/seconds.pass.cpp
+++ b/test/std/utilities/time/seconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::seconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 34, "");
     static_assert((std::is_same<Period, std::ratio<1> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp b/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
index 3a3978cb0..5c945fab7 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
 
@@ -42,4 +42,6 @@ int main()
         day day(i);
         assert(static_cast<unsigned>(day) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
index c53af6511..f5323f659 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     ASSERT_NOEXCEPT(--(std::declval<day&>())  );
@@ -48,4 +48,6 @@ int main()
         assert(static_cast<unsigned>(day--) == i - 1);
         assert(static_cast<unsigned>(day)   == i - 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
index b26d2285a..0be8c847f 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     ASSERT_NOEXCEPT(++(std::declval<day&>())  );
@@ -48,4 +48,6 @@ int main()
         assert(static_cast<unsigned>(day++) == i + 1);
         assert(static_cast<unsigned>(day)   == i + 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
index 8a04298ab..131df7533 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     ASSERT_NOEXCEPT(                std::declval<const day>().ok());
@@ -33,4 +33,6 @@ int main()
         assert(day{i}.ok());
     for (unsigned i = 32; i <= 255; ++i)
         assert(!day{i}.ok());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
index 42f12af55..d182d6c92 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day  = std::chrono::day;
     using days = std::chrono::days;
@@ -53,4 +53,6 @@ int main()
         assert(static_cast<unsigned>(day -= days{12}) == i + 10);
         assert(static_cast<unsigned>(day)             == i + 10);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
index 6b8a42772..75bc4cf52 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
 
@@ -40,4 +40,6 @@ int main()
     for (unsigned i = 1; i < 10; ++i)
         for (unsigned j = 1; j < 10; ++j)
             assert(testComparisons6Values<day>(i, j));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
index 36352fa35..6331bcf1b 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     day d1 = 4d; // expected-error-re {{no matching literal operator for call to 'operator""d' {{.*}}}}
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
index b3febd4eb..a887736f6 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     using namespace std::chrono;
@@ -43,4 +43,6 @@ int main()
     assert (d1 == std::chrono::day(4));
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
index 4953d1afe..e8ade305a 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day  = std::chrono::day;
     using days = std::chrono::days;
@@ -54,4 +54,6 @@ int main()
         assert(static_cast<unsigned>(d1) == 12 - i);
         assert(off.count() == static_cast<int>(12 - i)); // days is signed
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
index 10cec0a62..e219c7d3c 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day  = std::chrono::day;
     using days = std::chrono::days;
@@ -55,4 +55,6 @@ int main()
         assert(static_cast<unsigned>(d1) == i + 12);
         assert(static_cast<unsigned>(d2) == i + 12);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
index ad3d4f3f9..23ce736c6 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
@@ -48,8 +48,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using day = std::chrono::day;
    std::cout << day{1};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
index d437a6ae3..3c26c5753 100644
--- a/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
 
     static_assert(std::is_trivially_copyable_v<day>, "");
     static_assert(std::is_standard_layout_v<day>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
index 10396919b..084a6aa8d 100644
--- a/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using last_spec = std::chrono::last_spec;
 
@@ -29,4 +29,6 @@ int main()
 
     static_assert(std::is_trivially_copyable_v<last_spec>, "");
     static_assert(std::is_standard_layout_v<last_spec>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
index f3dadd2f6..48642987a 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -43,4 +43,6 @@ int main()
     static_assert( md1.month() == std::chrono::January, "");
     static_assert( md1.day()   == day{4},               "");
     static_assert( md1.ok(),                            "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
index c9c247d50..7137433a9 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month_day = std::chrono::month_day;
@@ -34,4 +34,6 @@ int main()
         month_day md(std::chrono::March, day{i});
         assert( static_cast<unsigned>(md.day()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
index e1b46190f..b4744e6d4 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -35,4 +35,6 @@ int main()
         month_day md(month{i}, day{1});
         assert( static_cast<unsigned>(md.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
index 649f09968..5e4c0082f 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -51,4 +51,6 @@ int main()
 //  If the month is not ok, all the days are bad
     for (unsigned i = 1; i <= 35; ++i)
         assert(!(month_day{month{13}, day{i}}.ok()));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
index c186f594c..d7e535a72 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -66,4 +66,6 @@ int main()
                 month_day{month{2}, day{j}},
                 i == j, i < j )));
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
index dbebdfa7d..8eef5f030 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
@@ -31,10 +31,12 @@
 #include <iostream>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day = std::chrono::month_day;
     using month     = std::chrono::month;
     using day       = std::chrono::day;
     std::cout << month_day{month{1}, day{1}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
index ba7c336a6..507855a99 100644
--- a/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day = std::chrono::month_day;
 
     static_assert(std::is_trivially_copyable_v<month_day>, "");
     static_assert(std::is_standard_layout_v<month_day>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
index ba9eda73a..265e7be37 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month          = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -39,4 +39,6 @@ int main()
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons6Values<month_day_last>(month{i}, month{j})));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
index 4bf983f3b..3696bb907 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month     = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -37,4 +37,6 @@ int main()
     constexpr month_day_last md1{std::chrono::January};
     static_assert( md1.month() == std::chrono::January, "");
     static_assert( md1.ok(),                            "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
index b9945b6d8..6bf75892d 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month     = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -34,4 +34,6 @@ int main()
         month_day_last mdl(month{i});
         assert( static_cast<unsigned>(mdl.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
index 38c52e229..730ab3b25 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month          = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -42,4 +42,6 @@ int main()
         month_day_last mdl{month{i}};
         assert(!mdl.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
index ebb915598..1b4a8f108 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
@@ -25,9 +25,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day_last = std::chrono::month_day_last;
     using month          = std::chrono::month;
     std::cout << month_day_last{month{1}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
index e3f02a885..c6eebc42d 100644
--- a/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day_last = std::chrono::month_day_last;
 
     static_assert(std::is_trivially_copyable_v<month_day_last>, "");
     static_assert(std::is_standard_layout_v<month_day_last>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
index d0ed4d37d..6800a03e1 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -42,4 +42,6 @@ int main()
         month m(i);
         assert(static_cast<unsigned>(m) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
index 2cab328cf..6d7edc508 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -49,4 +49,6 @@ int main()
         assert(static_cast<unsigned>(month--) == i - 1);
         assert(static_cast<unsigned>(month)   == i - 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
index 81162edf6..7bcd5bed7 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
     ASSERT_NOEXCEPT(++(std::declval<month&>())  );
@@ -48,4 +48,6 @@ int main()
         assert(static_cast<unsigned>(month++) == i + 1);
         assert(static_cast<unsigned>(month)   == i + 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
index 7cb5edad4..a001c74a3 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -34,4 +34,6 @@ int main()
         assert(month{i}.ok());
     for (unsigned i = 13; i <= 255; ++i)
         assert(!month{i}.ok());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
index 7ca4a6e5f..a792072af 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
@@ -63,4 +63,6 @@ int main()
         assert(static_cast<unsigned>(month -= months{ 9}) == static_cast<unsigned>(exp));
         assert(static_cast<unsigned>(month)               == static_cast<unsigned>(exp));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
index aa37fde3b..f69fec8aa 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_comparisons.h"
 
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -43,4 +43,6 @@ int main()
     for (unsigned i = 1; i < 10; ++i)
         for (unsigned j = 10; j < 10; ++j)
             assert(testComparisons6Values<month>(i, j));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
index 807cf2988..9832fe376 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
     ASSERT_SAME_TYPE(const std::chrono::month, decltype(std::chrono::January));
@@ -83,4 +83,6 @@ int main()
     assert(static_cast<unsigned>(std::chrono::October)   == 10);
     assert(static_cast<unsigned>(std::chrono::November)  == 11);
     assert(static_cast<unsigned>(std::chrono::December)  == 12);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
index 291d299e3..cda364127 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
@@ -44,7 +44,7 @@ constexpr bool testConstexpr()
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
@@ -68,4 +68,6 @@ static_assert(testConstexpr<month, months>(), "");
         assert(static_cast<unsigned>(m1) == static_cast<unsigned>(exp));
 //          assert(off.count()               == static_cast<unsigned>(exp));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
index 87b39003b..58a951e1b 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
@@ -43,7 +43,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
@@ -68,4 +68,6 @@ int main()
         assert(static_cast<unsigned>(m1) == exp);
         assert(static_cast<unsigned>(m2) == exp);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
index 5f3f3884f..1d3aa7ce4 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
@@ -45,8 +45,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using month = std::chrono::month;
    std::cout << month{1};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
index b3e502465..a6e67f101 100644
--- a/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
     static_assert(std::is_trivially_copyable_v<month>, "");
     static_assert(std::is_standard_layout_v<month>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
index 8d0b560b1..8804e71e3 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -42,4 +42,6 @@ int main()
     static_assert( md1.month() == std::chrono::January,                              "");
     static_assert( md1.weekday_indexed() == weekday_indexed{std::chrono::Friday, 4}, "");
     static_assert( md1.ok(),                                                         "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
index 99bdcb160..35e7c83c7 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -38,4 +38,6 @@ int main()
         month_weekday md(month{i}, weekday_indexed{Sunday, 1});
         assert( static_cast<unsigned>(md.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
index b4999652f..2ff1bf735 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -47,4 +47,6 @@ int main()
 //  If the month is not ok, all the weekday_indexed are bad
     for (unsigned i = 1; i <= 10; ++i)
         assert(!(month_weekday{month{13}, weekday_indexed{Sunday, i}}.ok()));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
index d80ae29d0..13a1bba53 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -39,4 +39,6 @@ int main()
         assert( static_cast<unsigned>(md.weekday_indexed().weekday() == Sunday));
         assert( static_cast<unsigned>(md.weekday_indexed().index() == i));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
index 64df8840e..46f756de0 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -82,4 +82,6 @@ int main()
                 month_weekday{month{2}, weekday_indexed{weekday{i}, 2}},
                 month_weekday{month{2}, weekday_indexed{weekday{j}, 2}},
                 i == j)));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
index e7981b571..11a1d4ecd 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -32,4 +32,6 @@ int main()
     using weekday         = std::chrono::weekday;
 
     std::cout << month_weekday{month{1}, weekday_indexed{weekday{3}, 3}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
index 67c3f17b9..bd4f4e1d4 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday = std::chrono::month_weekday;
 
     static_assert(std::is_trivially_copyable_v<month_weekday>, "");
     static_assert(std::is_standard_layout_v<month_weekday>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
index fa5ca0443..d83bbe92f 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -56,4 +56,6 @@ int main()
     static_assert( mwdl3.month() == January,                         "");
     static_assert( mwdl3.weekday_last() == weekday_last{weekday{4}}, "");
     static_assert( mwdl3.ok(),                                       "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
index 3561651c2..a32b08996 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -38,4 +38,6 @@ int main()
         month_weekday_last mdl(month{i}, weekday_last{Tuesday});
         assert( static_cast<unsigned>(mdl.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
index 10245f938..02df5fbd2 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -48,4 +48,6 @@ int main()
         month_weekday_last mwdl{January, weekday_last{weekday{i}}};
         assert( mwdl.ok() == weekday_last{weekday{i}}.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
index 4afa6cca7..4ecf6d246 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -40,4 +40,6 @@ int main()
         month_weekday_last mdl(January, weekday_last{weekday{i}});
         assert( static_cast<unsigned>(mdl.weekday_last().weekday()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
index 4d0e935f1..911693c25 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday_last       = std::chrono::weekday_last;
@@ -69,4 +69,6 @@ int main()
             month_weekday_last{month{1}, weekday_last{weekday{1}}},
             month_weekday_last{month{2}, weekday_last{weekday{2}}},
         false)));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
index 2bf0e1ec4..75654b1b3 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday_last = std::chrono::month_weekday_last;
     using month              = std::chrono::month;
@@ -33,4 +33,6 @@ int main()
     using weekday_last       = std::chrono::weekday_last;
 
     std::cout << month_weekday_last{month{1}, weekday_last{weekday{3}}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
index 2271f42c0..2f2676d7a 100644
--- a/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday_last = std::chrono::month_weekday_last;
 
     static_assert(std::is_trivially_copyable_v<month_weekday_last>, "");
     static_assert(std::is_standard_layout_v<month_weekday_last>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
index e51fb4fa4..e9eb80bfd 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
@@ -38,7 +38,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_day = std::chrono::month_day;
     using month     = std::chrono::month;
@@ -104,4 +104,6 @@ int main()
                 assert(md1 == md2);
             }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
index 27043b88c..84c2c6eaa 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
@@ -46,7 +46,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month          = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -103,4 +103,6 @@ int main()
         }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
index 4dc6db768..60b788de1 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
@@ -44,7 +44,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -111,4 +111,6 @@ int main()
                     assert(mwd1 == mwd2);
                 }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
index 25d25b26d..07e5d8d75 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
@@ -36,7 +36,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday      = std::chrono::month_weekday;
     using month              = std::chrono::month;
@@ -103,4 +103,6 @@ int main()
                 assert(mwd1 == mwd2);
             }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
index 6ef320ebb..ba2b5c187 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using year       = std::chrono::year;
@@ -64,4 +64,6 @@ int main()
                 assert(static_cast<unsigned>(ym.month()) == j);
             }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
index a8df70096..a5aa4d0ef 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
@@ -42,7 +42,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -187,4 +187,6 @@ int main()
                 }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
index 2556bb93f..fd55e38b4 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
@@ -38,7 +38,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month               = std::chrono::month;
     using year_month          = std::chrono::year_month;
@@ -121,4 +121,6 @@ int main()
                 assert(ymdl1 == ymdl2);
             }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
index af27c945e..4e7143580 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
@@ -37,7 +37,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using year_month         = std::chrono::year_month;
@@ -141,4 +141,6 @@ int main()
                         assert(ymd1 == ymd2);
                     }
      }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
index ff467aa60..62b1f4676 100644
--- a/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
@@ -39,7 +39,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year_month         = std::chrono::year_month;
     using year               = std::chrono::year;
@@ -149,4 +149,6 @@ int main()
                     assert(ymwdl1 == ymwdl2);
                 }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
index b9facef63..4a64b932b 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday  = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -57,4 +57,6 @@ int main()
         weekday_indexed wdi(std::chrono::Tuesday, i);
         assert(!wdi.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
index 043a98acc..4942f7164 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -34,4 +34,6 @@ int main()
         weekday_indexed wdi(weekday{2}, i);
         assert( static_cast<unsigned>(wdi.index()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
index 1cdfb29c9..a2b5b48e4 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -45,4 +45,6 @@ int main()
 
 //  Not a valid weekday
     assert(!(weekday_indexed(weekday{9U}, 1).ok()));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
index 47f50b6d6..e9c204d08 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -35,4 +35,6 @@ int main()
         weekday_indexed wdi(weekday{i}, 2);
         assert( static_cast<unsigned>(wdi.weekday()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
index 963f9f15e..104c59abf 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -44,4 +44,6 @@ int main()
     static_assert( (weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{1}, 1}), "");
     static_assert(!(weekday_indexed{weekday{1}, 2} == weekday_indexed{weekday{2}, 2}),  "");
     static_assert( (weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{2}, 2}),  "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
index 810b2cb0c..5052a1824 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
@@ -26,10 +26,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday_indexed = std::chrono::weekday_indexed;
     using weekday         = std::chrono::weekday;
 
     std::cout << weekday_indexed{weekday{3}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
index 74634da8a..260b50f46 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday_indexed = std::chrono::weekday_indexed;
 
     static_assert(std::is_trivially_copyable_v<weekday_indexed>, "");
     static_assert(std::is_standard_layout_v<weekday_indexed>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
index f7fa66320..a569144d0 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -43,4 +43,6 @@ int main()
         weekday_last wdl{weekday{i}};
         assert(wdl.weekday() == weekday{i});
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
index d708a8124..eb0636aa9 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -33,4 +33,6 @@ int main()
 
     for (unsigned i = 0; i <= 255; ++i)
         assert(weekday_last{weekday{i}}.ok() == weekday{i}.ok());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
index 48767b3b8..c5eb6e132 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -29,4 +29,6 @@ int main()
 
     for (unsigned i = 0; i <= 255; ++i)
         assert(weekday_last{weekday{i}}.weekday() == weekday{i});
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
index 1a9fc97eb..c5ca36e82 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -39,4 +39,6 @@ int main()
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
             assert(testComparisons2Values<weekday_last>(weekday{i}, weekday{j}));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
index efb598472..85a40a3dc 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
@@ -24,10 +24,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using weekday_last = std::chrono::weekday_last;
    using weekday      = std::chrono::weekday;
 
    std::cout << weekday_last{weekday{3}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
index c986f99c3..ff9d54f88 100644
--- a/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday_last = std::chrono::weekday_last;
 
     static_assert(std::is_trivially_copyable_v<weekday_last>, "");
     static_assert(std::is_standard_layout_v<weekday_last>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
index ee241c8e7..06656fb44 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using local_days = std::chrono::local_days;
     using days       = std::chrono::days;
@@ -69,4 +69,6 @@ int main()
     assert( wd.ok());
     assert(static_cast<unsigned>(wd) == 3);
     }
+
+    return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
index 9ec3afb21..470b9d79d 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
@@ -47,4 +47,6 @@ int main()
     }
 
 // TODO - sys_days and local_days ctor tests
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
index 920b53e78..e00184a99 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using sys_days  = std::chrono::sys_days;
     using days      = std::chrono::days;
@@ -69,4 +69,6 @@ int main()
     assert( wd.ok());
     assert(static_cast<unsigned>(wd) == 3);
     }
+
+    return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
index c8b023a37..d574e1db9 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
@@ -31,7 +31,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     ASSERT_NOEXCEPT(--(std::declval<weekday&>())  );
@@ -49,4 +49,6 @@ int main()
         assert((static_cast<unsigned>(wd--) == euclidian_subtraction<unsigned, 0, 6>(i, 1)));
         assert((static_cast<unsigned>(wd)   == euclidian_subtraction<unsigned, 0, 6>(i, 2)));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
index d9239ff8f..bb62e0120 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
@@ -31,7 +31,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     ASSERT_NOEXCEPT(++(std::declval<weekday&>())  );
@@ -49,4 +49,6 @@ int main()
         assert((static_cast<unsigned>(wd++) == euclidian_addition<unsigned, 0, 6>(i, 1)));
         assert((static_cast<unsigned>(wd)   == euclidian_addition<unsigned, 0, 6>(i, 2)));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
index f8bd9d43a..f2f6e2e98 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
@@ -34,4 +34,6 @@ int main()
         assert(weekday{i}.ok());
     for (unsigned i = 7; i <= 255; ++i)
         assert(!weekday{i}.ok());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
index aa0f3f7e5..d7d2d6faf 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "../../euclidian.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_last    = std::chrono::weekday_last;
@@ -55,4 +55,6 @@ int main()
         assert(wdi.index() == j);
         assert(wdi.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
index e0963540c..d99b03493 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     using days    = std::chrono::days;
@@ -59,4 +59,6 @@ int main()
         assert((static_cast<unsigned>(wd -= days{4}) == euclidian_subtraction<unsigned, 0, 6>(i, 4)));
         assert((static_cast<unsigned>(wd)            == euclidian_subtraction<unsigned, 0, 6>(i, 4)));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
index c042ac147..982b3bccb 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
@@ -38,4 +38,6 @@ int main()
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
             assert(testComparisons2Values<weekday>(i, j));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
index 8f713aad2..7529864a5 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
     ASSERT_SAME_TYPE(const std::chrono::weekday, decltype(std::chrono::Sunday));
@@ -58,4 +58,6 @@ int main()
     assert(static_cast<unsigned>(std::chrono::Thursday)  ==  4);
     assert(static_cast<unsigned>(std::chrono::Friday)    ==  5);
     assert(static_cast<unsigned>(std::chrono::Saturday)  ==  6);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
index 2bf0ed789..f296fc6d6 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
@@ -44,7 +44,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday  = std::chrono::weekday;
     using days     = std::chrono::days;
@@ -72,4 +72,6 @@ int main()
             assert(weekday{i} + d == weekday{j});
         }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
index 287834cd7..78d332b96 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
@@ -44,7 +44,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     using days    = std::chrono::days;
@@ -66,4 +66,6 @@ int main()
             assert((static_cast<unsigned>(wd1) == euclidian_addition<unsigned, 0, 6>(i, j)));
             assert((static_cast<unsigned>(wd2) == euclidian_addition<unsigned, 0, 6>(i, j)));
         }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
index aef5a82e7..43825b60e 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
@@ -47,9 +47,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using weekday = std::chrono::weekday;
 
    std::cout << weekday{3};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
index ed355b025..7264a210f 100644
--- a/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
     static_assert(std::is_trivially_copyable_v<weekday>, "");
     static_assert(std::is_standard_layout_v<weekday>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
index 5f8b4660a..e46b55630 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -42,4 +42,6 @@ int main()
         year year(i);
         assert(static_cast<int>(year) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
index e8473bf98..893c48aab 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
     ASSERT_NOEXCEPT(--(std::declval<year&>())  );
@@ -48,4 +48,6 @@ int main()
         assert(static_cast<int>(year--) == i - 1);
         assert(static_cast<int>(year)   == i - 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
index 759fb6661..ef2a6f3fb 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
@@ -30,7 +30,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
     ASSERT_NOEXCEPT(++(std::declval<year&>())  );
@@ -48,4 +48,6 @@ int main()
         assert(static_cast<int>(year++) == i + 1);
         assert(static_cast<int>(year)   == i + 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
index b1785b86c..37031dbba 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -49,4 +49,6 @@ int main()
     assert(!year{ 2003}.is_leap());
     assert( year{ 2004}.is_leap());
     assert(!year{ 2100}.is_leap());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
index dfc2ad3ff..f56ee34d5 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -49,4 +49,6 @@ int main()
     assert(year{ 20001}.ok());
 
     static_assert(!year{-32768}.ok(), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
index 65b149458..0adb0f9fe 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
@@ -28,7 +28,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
 
@@ -46,4 +46,6 @@ int main()
         assert(static_cast<int>(+year) ==  i);
         assert(static_cast<int>(-year) == -i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
index a00a36f2d..b79713ed1 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
     using years = std::chrono::years;
@@ -53,4 +53,6 @@ int main()
         assert(static_cast<int>(year -= years{ 9}) == i +  1);
         assert(static_cast<int>(year)              == i +  1);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
index 8d675f4db..9e84fe36e 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_comparisons.h"
 
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -43,4 +43,6 @@ int main()
     for (int i = 1; i < 10; ++i)
         for (int j = 1; j < 10; ++j)
             assert(testComparisons6Values<year>(i, j));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
index c6138c7af..50c7b7bc0 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::chrono::year;
     year d1 = 1234y; // expected-error-re {{no matching literal operator for call to 'operator""y' {{.*}}}}
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
index 6ebd0e66f..a2bec73e6 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     using namespace std::chrono;
@@ -40,4 +40,6 @@ int main()
     std::chrono::year y1 = 2020y;
     assert (y1 == std::chrono::year(2020));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
index 3e3e0b77d..f112345c0 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
@@ -37,7 +37,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
     using years = std::chrono::years;
@@ -58,4 +58,6 @@ int main()
         assert(static_cast<int>(y1) == 1223 - i);
         assert(ys1.count()          == 1223 - i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
index 15c713def..d73f6fc88 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool testConstexpr()
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
     using years = std::chrono::years;
@@ -55,4 +55,6 @@ int main()
         assert(static_cast<int>(y1) == i + 1223);
         assert(static_cast<int>(y2) == i + 1223);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
index 2c52cde0a..1b278f2b9 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
@@ -46,9 +46,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using year = std::chrono::year;
 
    std::cout << year{2018};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
index 10bea23a0..2acb0f104 100644
--- a/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
     static_assert(std::is_trivially_copyable_v<year>, "");
     static_assert(std::is_standard_layout_v<year>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
index 090a1ac21..1c05cf7a6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -48,4 +48,6 @@ int main()
     static_assert( ym2.year()  == year{2018}, "");
     static_assert( ym2.month() == month{},    "");
     static_assert(!ym2.ok(),                  "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
index 97334b205..7e0cd17f4 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -35,4 +35,6 @@ int main()
         year_month ym(year{1234}, month{i});
         assert( static_cast<unsigned>(ym.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
index 54e67dff9..463289ee4 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using year       = std::chrono::year;
@@ -46,4 +46,6 @@ int main()
         year_month ym{year{i}, January};
         assert( ym.ok() == year{i}.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
index 76f3b3355..a403462ff 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using months     = std::chrono::months;
@@ -60,4 +60,6 @@ int main()
         assert(static_cast<unsigned>((ym             ).month()) == i + 1);
         assert(ym.year() == y);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
index 05cd60844..adf08fc24 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using year       = std::chrono::year;
@@ -61,4 +61,6 @@ int main()
         assert(static_cast<int>((ym            ).year()) == i + 1);
         assert(ym.month() == m);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
index e8476b042..024f31404 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -35,4 +35,6 @@ int main()
         year_month ym(year{i}, month{});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
index e1ab033c7..d102b0a56 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -65,4 +65,6 @@ int main()
             year_month{year{i}, std::chrono::January},
             year_month{year{j}, std::chrono::January},
             i == j, i < j )));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
index 2999560f1..d7756d10d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
@@ -29,7 +29,7 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using years      = std::chrono::years;
@@ -86,4 +86,6 @@ int main()
 //  TODO: different year
 
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
index dc721adee..5698e7244 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
@@ -51,7 +51,7 @@ constexpr bool testConstexprMonths(std::chrono::year_month ym)
 }
 
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using years      = std::chrono::years;
@@ -102,4 +102,6 @@ int main()
         assert(ym1 == ym2);
     }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
index e75fc21bf..43af6c2f7 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
@@ -46,11 +46,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month = std::chrono::year_month;
     using year       = std::chrono::year;
     using month      = std::chrono::month;
 
     std::cout << year_month{year{2018}, month{3}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
index a3b9999f8..2e88c6bb6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month = std::chrono::year_month;
 
     static_assert(std::is_trivially_copyable_v<year_month>, "");
     static_assert(std::is_standard_layout_v<year_month>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
index 9cebaa683..274cb6a26 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using day            = std::chrono::day;
@@ -81,4 +81,6 @@ int main()
     assert( ymd.month() == std::chrono::November);
     assert( ymd.day()   == day{29});
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
index a5818849a..fdef9517e 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -52,4 +52,6 @@ int main()
     static_assert( ym1.day()   == day{12},    "");
     static_assert( ym1.ok(),                  "");
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
index 7344c10c1..433468477 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using day            = std::chrono::day;
@@ -80,4 +80,6 @@ int main()
     assert( ymd.month() == std::chrono::November);
     assert( ymd.day()   == day{29});
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
index 913b40395..d4e8fc83d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -76,4 +76,6 @@ int main()
     assert( ymd.day()   == day{28});
     assert( ymd.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
index 12e1515b1..9a068737d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -36,4 +36,6 @@ int main()
         year_month_day ymd(year{1234}, month{2}, day{i});
         assert( static_cast<unsigned>(ymd.day()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
index 8c091d051..f1dd2e689 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -36,4 +36,6 @@ int main()
         year_month_day ymd(year{1234}, month{i}, day{12});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
index edb55f58b..cab639b82 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -92,4 +92,6 @@ int main()
         year_month_day ym{year{i}, January, day{12}};
         assert( ym.ok() == year{i}.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
index 02212dc90..038d21c46 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
@@ -44,7 +44,7 @@ void RunTheExample()
     static_assert(year_month_day{local_days{year{2017}/January/32}} == year{2017}/February/1);  
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -90,4 +90,5 @@ int main()
     assert( year_month_day{sd} == ymd); // and back
     }
 
+    return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
index 5925cb0cb..a95684550 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
@@ -44,7 +44,7 @@ void RunTheExample()
     static_assert(year_month_day{sys_days{year{2017}/January/32}} == year{2017}/February/1);  
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -90,4 +90,5 @@ int main()
     assert( year_month_day{sd} == ymd); // and back
     }
 
+    return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
index 173b8b6a2..8530248d1 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -66,4 +66,6 @@ int main()
         assert(ym.year() == y);
         assert(ym.day()  == d);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
index 1d9951291..ae134d1a2 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -66,4 +66,6 @@ int main()
         assert(ym.month() == m);
         assert(ym.day()   == d);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
index 465fa9d93..fc5a40724 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -36,4 +36,6 @@ int main()
         year_month_day ym(year{i}, month{}, day{});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
index 8d5bf8955..0d1558925 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using day        = std::chrono::day;
     using year       = std::chrono::year;
@@ -114,4 +114,6 @@ int main()
             year_month_day{year{i}, January, day{12}},
             year_month_day{year{j}, January, day{12}},
             i == j, i < j )));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
index 4d5625ba7..3c921def3 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
@@ -33,7 +33,7 @@ constexpr bool test_constexpr ()
         ;
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -56,4 +56,6 @@ int main()
         assert(ym1.month() == January);
         assert(ym1.day() == day{10});
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
index 2913eb237..8d5e02543 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
@@ -51,7 +51,7 @@ constexpr bool testConstexprMonths(std::chrono::year_month_day ym)
 }
 
 
-int main()
+int main(int, char**)
 {
     using day        = std::chrono::day;
     using year       = std::chrono::year;
@@ -108,4 +108,6 @@ int main()
     }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
index cce42bc61..47b6f0249 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
@@ -46,7 +46,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_day = std::chrono::year_month_day;
     using year           = std::chrono::year;
@@ -54,4 +54,6 @@ int main()
     using day            = std::chrono::day;
 
     std::cout << year_month_day{year{2018}, month{3}, day{12}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
index c61d1c996..58acd143d 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_day = std::chrono::year_month_day;
 
     static_assert(std::is_trivially_copyable_v<year_month_day>, "");
     static_assert(std::is_standard_layout_v<year_month_day>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
index d27c3c67e..bd4729f6a 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -49,4 +49,6 @@ int main()
     static_assert( ymdl1.month()          == January,                 "");
     static_assert( ymdl1.month_day_last() == month_day_last{January}, "");
     static_assert( ymdl1.ok(),                                        "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
index 24682b695..2f0e2ba17 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -47,4 +47,6 @@ int main()
     assert((year_month_day_last{year{2019}, month_day_last{month{ 2}}}.day() == day{28}));
     assert((year_month_day_last{year{2020}, month_day_last{month{ 2}}}.day() == day{29}));
     assert((year_month_day_last{year{2021}, month_day_last{month{ 2}}}.day() == day{28}));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
index cf1024a8c..5b68aa1d9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -34,4 +34,6 @@ int main()
         year_month_day_last ymd(year{1234}, month_day_last{month{i}});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
index 5c99d9471..cca9026b6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -34,4 +34,6 @@ int main()
         year_month_day_last ymdl(year{1234}, month_day_last{month{i}});
         assert( static_cast<unsigned>(ymdl.month_day_last().month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
index bb4c410d4..d40de103c 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -48,4 +48,6 @@ int main()
         year_month_day_last ym{year{i}, month_day_last{January}};
         assert( ym.ok() == year{i}.ok());
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
index 83f8b70dc..a96dff338 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month_day_last      = std::chrono::month_day_last;
@@ -57,4 +57,6 @@ int main()
 
     assert(sd.time_since_epoch() == days{-(10957+33)});
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
index 9a32112c9..250ca0f11 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month_day_last      = std::chrono::month_day_last;
@@ -57,4 +57,6 @@ int main()
 
     assert(sd.time_since_epoch() == days{-(10957+33)});
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
index 2c4d1ff1f..7091f64ea 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -62,4 +62,6 @@ int main()
         assert(static_cast<unsigned>((ym             ).month()) == i + 1);
         assert(ym.year() == y);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
index 00335e15d..3c1ad3527 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -61,4 +61,6 @@ int main()
         assert(static_cast<int>((ymdl            ).year()) == i + 1);
         assert(ymdl.month_day_last() == mdl);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
index 49387091d..c0db150f9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -34,4 +34,6 @@ int main()
         year_month_day_last ym(year{i}, month_day_last{month{}});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
index 9db4b6aa6..c56491f96 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -83,4 +83,6 @@ int main()
             year_month_day_last{year{i}, month_day_last{January}},
             year_month_day_last{year{j}, month_day_last{January}},
             i == j, i < j )));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
index 7f5a796df..8ea3025d6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
@@ -47,7 +47,7 @@ constexpr bool testConstexprMonths (std::chrono::year_month_day_last ymdl)
         ;
 }
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -87,4 +87,6 @@ int main()
     }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
index c494620df..75cabbdcd 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
@@ -63,7 +63,7 @@ constexpr bool testConstexprMonths(std::chrono::year_month_day_last ymdl)
 }
 
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -118,4 +118,6 @@ int main()
     }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
index 268eb88fe..eca8d3d68 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_day_last = std::chrono::year_month_day_last;
     using year                = std::chrono::year;
@@ -33,4 +33,6 @@ int main()
     using month_day_last      = std::chrono::month_day_last;
 
     std::cout << year_month_day_last{year{2018}, month_day_last{month{3}}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
index 0eae24e45..bb4e7d044 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using days               = std::chrono::days;
@@ -91,4 +91,6 @@ int main()
     assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
     assert( ymwd                   == year_month_weekday{local_days{ymwd}}); // round trip
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
index dab8b2157..81030ff55 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -60,4 +60,6 @@ int main()
     static_assert( ym1.weekday_indexed() == weekday_indexed{Tuesday, 1}, "");
     static_assert( ym1.ok(),                                             "");
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
index 96261c54e..5ae9900a9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using days               = std::chrono::days;
@@ -90,4 +90,6 @@ int main()
     assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
     assert( ymwd                   == year_month_weekday{sys_days{ymwd}}); // round trip
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
index 4c0bc13c1..ecbd8aec8 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -37,4 +37,6 @@ int main()
         year_month_weekday ymwd0(year{1234}, month{2}, weekday_indexed{weekday{2}, i});
         assert(ymwd0.index() == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
index 0e2d41a77..c300fd5d3 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -36,4 +36,6 @@ int main()
         year_month_weekday ymd(year{1234}, month{i}, weekday_indexed{});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
index f66d6a083..7e8599e05 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -71,4 +71,6 @@ int main()
         year_month_weekday ym{year{i}, January, weekday_indexed{Tuesday, 1}};
         assert((ym.ok() == year{i}.ok()));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
index 788af6535..e86e5b0fa 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -70,4 +70,5 @@ int main()
     assert( year_month_weekday{sd} == ymwd); // and back
     }
 
+    return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
index 111cf5f38..afb1d7014 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -70,4 +70,5 @@ int main()
     assert( year_month_weekday{sd} == ymwd); // and back
     }
 
+    return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
index 7e20a8eb0..fd53279dd 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -76,4 +76,6 @@ int main()
         assert(ymwd.weekday()  == Tuesday);
         assert(ymwd.index()    == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
index 4deee9bc3..cf229febe 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -76,4 +76,6 @@ int main()
         assert(ymwd.weekday()  == Tuesday);
         assert(ymwd.index()    == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
index 1b9c8ad10..dac1f7cc0 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -37,4 +37,6 @@ int main()
         year_month_weekday ymwd0(year{1234}, month{2}, weekday_indexed{weekday{i}, 1});
         assert(static_cast<unsigned>(ymwd0.weekday()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
index 4a9832323..f089a8cb9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -41,4 +41,6 @@ int main()
         assert( static_cast<unsigned>(ymwd1.weekday_indexed().weekday()) == 2);
         assert( static_cast<unsigned>(ymwd1.weekday_indexed().index()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
index 8103c28aa..1ead67570 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -36,4 +36,6 @@ int main()
         year_month_weekday ym(year{i}, month{1}, weekday_indexed{});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
index 847699b25..563112722 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -109,4 +109,6 @@ int main()
             year_month_weekday{year{i}, January, weekday_indexed{Tuesday, 1}},
             year_month_weekday{year{j}, January, weekday_indexed{Tuesday, 1}},
             i == j)));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
index ff472fdc6..47cfbea6a 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
@@ -50,7 +50,7 @@ constexpr bool testConstexprMonths ()
 }
 
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -96,4 +96,6 @@ int main()
         assert(ym1.index()   == 2);
     }
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
index bc72d958c..29df4776e 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
@@ -51,7 +51,7 @@ constexpr bool testConstexprMonths(std::chrono::year_month_weekday ym)
 }
 
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -116,4 +116,6 @@ int main()
     }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
index eb92cf05e..411e4335f 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
@@ -45,7 +45,7 @@
 #include <iostream>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday = std::chrono::year_month_weekday;
     using year                = std::chrono::year;
@@ -53,4 +53,6 @@ int main()
     using weekday             = std::chrono::weekday;
 
     std::cout << year_month_weekday{year{2018}, month{3}, weekday{4}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
index 449098c4f..76e2e0f23 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday = std::chrono::year_month_weekday;
 
     static_assert(std::is_trivially_copyable_v<year_month_weekday>, "");
     static_assert(std::is_standard_layout_v<year_month_weekday>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
index 1db6850db..31d2e9ca7 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -48,4 +48,6 @@ int main()
     static_assert( ym1.weekday_last() == weekday_last{Tuesday}, "");
     static_assert( ym1.ok(),                                    "");
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
index 7b95084b2..df62d010a 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -37,4 +37,6 @@ int main()
         year_month_weekday_last ymd(year{1234}, month{i}, weekday_last{weekday{}});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
index 1cffb4565..c18b92670 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -69,4 +69,6 @@ int main()
         year_month_weekday_last ym{year{i}, January, weekday_last{Tuesday}};
         assert((ym.ok() == year{i}.ok()));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
index 83f8b70dc..c663406ee 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month_day_last      = std::chrono::month_day_last;
@@ -57,4 +57,6 @@ int main()
 
     assert(sd.time_since_epoch() == days{-(10957+33)});
     }
+
+    return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
index cc3da2992..cb75842c6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
@@ -22,7 +22,7 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -65,4 +65,6 @@ int main()
 
     assert(sd.time_since_epoch() == days{-(10957+35)});
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
index ad513c5d0..b2bb1361b 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -71,4 +71,6 @@ int main()
         assert(ymwd.year()     == y);
         assert(ymwd.weekday()  == Tuesday);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
index 7d9255fe4..8ced182d6 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@ constexpr bool testConstexpr(D d1)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -72,4 +72,6 @@ int main()
         assert(ymwd.month()    == January);
         assert(ymwd.weekday()  == Tuesday);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
index cc0521354..1de0b8323 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -37,4 +37,6 @@ int main()
         year_month_weekday_last ymwdl(year{1}, month{1}, weekday_last{weekday{i}});
         assert(static_cast<unsigned>(ymwdl.weekday()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
index 4011f0673..4e9407911 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -37,4 +37,6 @@ int main()
         year_month_weekday_last ymwdl(year{i}, month{1}, weekday_last{weekday{}});
         assert(static_cast<int>(ymwdl.year()) == i);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
index a13b11f8c..24074f33c 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -110,4 +110,6 @@ int main()
             year_month_weekday_last{year{i}, January, weekday_last{Tuesday}},
             year_month_weekday_last{year{j}, January, weekday_last{Tuesday}},
             i == j)));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
index 20a58152f..d58c461be 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
@@ -40,7 +40,7 @@ constexpr bool testConstexprMonths(std::chrono::year_month_weekday_last ym)
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -89,4 +89,6 @@ int main()
     }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
index 45dd7562d..fe246cf42 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
@@ -47,7 +47,7 @@ constexpr bool testConstexprMonths(std::chrono::year_month_weekday_last ym)
 }
 
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -112,4 +112,6 @@ int main()
     }
     }
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
index 6e4409c71..cdfe55f16 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday_last = std::chrono::year_month_weekday_last;
     using year                    = std::chrono::year;
@@ -34,4 +34,6 @@ int main()
     using weekday_last            = std::chrono::weekday_last;
 
     std::cout << year_month_weekday_last{year{2018}, month{3}, weekday_last{weekday{4}}};
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp b/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
index e0580fac7..70dea7bf9 100644
--- a/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
+++ b/test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday_last = std::chrono::year_month_weekday_last;
 
     static_assert(std::is_trivially_copyable_v<year_month_weekday_last>, "");
     static_assert(std::is_standard_layout_v<year_month_weekday_last>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp b/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp b/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
index 332d8163c..165bec2e1 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
@@ -22,7 +22,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::file_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -31,4 +31,6 @@ int main()
     static_assert((std::is_same<C::time_point::clock, C>::value), "");
     static_assert(!C::is_steady, "");
     test(std::chrono::file_clock::is_steady);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
index 75652f3ec..61d92381f 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
@@ -21,8 +21,10 @@ void test() {
   ASSERT_SAME_TYPE(std::chrono::file_time<Dur>, std::chrono::time_point<std::chrono::file_clock, Dur>);
 }
 
-int main() {
+int main(int, char**) {
   test<std::chrono::nanoseconds>();
   test<std::chrono::minutes>();
   test<std::chrono::hours>();
+
+  return 0;
 }
\ No newline at end of file
diff --git a/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
index 3b51b91b5..79cdf0612 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::file_clock C;
     ASSERT_NOEXCEPT(C::now());
@@ -31,4 +31,6 @@ int main()
     assert(t1.time_since_epoch().count() != 0);
     assert(C::time_point::min() < t1);
     assert(C::time_point::max() > t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp b/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
index c36649a5d..821072e6d 100644
--- a/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
@@ -20,9 +20,11 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_signed<std::chrono::file_clock::rep>::value, "");
     assert(std::chrono::file_clock::duration::min() <
            std::chrono::file_clock::duration::zero());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
index 6f06e718e..1650d3b6b 100644
--- a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
@@ -27,7 +27,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -35,4 +35,6 @@ int main()
     static_assert((std::is_same<C::duration, C::time_point::duration>::value), "");
     static_assert(C::is_steady || !C::is_steady, "");
     test(std::chrono::high_resolution_clock::is_steady);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
index c1d879c6f..ddf3ced87 100644
--- a/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
@@ -15,11 +15,13 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock C;
     C::time_point t1 = C::now();
     assert(t1.time_since_epoch().count() != 0);
     assert(C::time_point::min() < t1);
     assert(C::time_point::max() > t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
index 1577bc180..0797f2cb5 100644
--- a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
@@ -29,7 +29,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -37,4 +37,6 @@ int main()
     static_assert((std::is_same<C::duration, C::time_point::duration>::value), "");
     static_assert(C::is_steady, "");
     test(std::chrono::steady_clock::is_steady);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
index 248f1523f..7d268fd67 100644
--- a/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
@@ -17,10 +17,12 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock C;
     C::time_point t1 = C::now();
     C::time_point t2 = C::now();
     assert(t2 >= t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
index b15a8e212..b92652134 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
@@ -27,7 +27,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -36,4 +36,6 @@ int main()
     static_assert((std::is_same<C::time_point::clock, C>::value), "");
     static_assert((C::is_steady || !C::is_steady), "");
     test(std::chrono::system_clock::is_steady);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
index e6acef241..54252718d 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
@@ -15,9 +15,11 @@
 #include <chrono>
 #include <ctime>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     C::time_point t1 = C::from_time_t(C::to_time_t(C::now()));
     ((void)t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
index 398cdb9d7..5802166c8 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using local_t = std::chrono::local_t;
     using year    = std::chrono::year;
@@ -61,4 +61,6 @@ int main()
     ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
     assert( s0.time_since_epoch().count() == 0);
     assert( s1.time_since_epoch().count() == 946684800L);
+
+    return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
index 00a163685..9d74541f9 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
@@ -15,11 +15,13 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     C::time_point t1 = C::now();
     assert(t1.time_since_epoch().count() != 0);
     assert(C::time_point::min() < t1);
     assert(C::time_point::max() > t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
index cae8375d8..967af52e1 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
@@ -15,8 +15,10 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::system_clock::duration::min() <
            std::chrono::system_clock::duration::zero());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
index 516f54914..174fbe941 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using system_clock = std::chrono::system_clock;
     using year         = std::chrono::year;
@@ -60,4 +60,6 @@ int main()
     ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
     assert( s0.time_since_epoch().count() == 0);
     assert( s1.time_since_epoch().count() == 946684800L);
+
+    return 0;
 }
diff --git a/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
index 0819a7b54..86b37bb6b 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
@@ -15,9 +15,11 @@
 #include <chrono>
 #include <ctime>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     std::time_t t1 = C::to_time_t(C::now());
     ((void)t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/default_ratio.pass.cpp b/test/std/utilities/time/time.duration/default_ratio.pass.cpp
index 92c015eef..08870488c 100644
--- a/test/std/utilities/time/time.duration/default_ratio.pass.cpp
+++ b/test/std/utilities/time/time.duration/default_ratio.pass.cpp
@@ -18,8 +18,10 @@
 #include <chrono>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::chrono::duration<int, std::ratio<1> >,
                    std::chrono::duration<int> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/duration.fail.cpp b/test/std/utilities/time/time.duration/duration.fail.cpp
index 94e239c1f..02029c02b 100644
--- a/test/std/utilities/time/time.duration/duration.fail.cpp
+++ b/test/std/utilities/time/time.duration/duration.fail.cpp
@@ -15,8 +15,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<std::chrono::milliseconds> D;
     D d;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/positive_num.fail.cpp b/test/std/utilities/time/time.duration/positive_num.fail.cpp
index 6e78f7765..737576205 100644
--- a/test/std/utilities/time/time.duration/positive_num.fail.cpp
+++ b/test/std/utilities/time/time.duration/positive_num.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<int, std::ratio<5, -1> > D;
     D d;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/ratio.fail.cpp b/test/std/utilities/time/time.duration/ratio.fail.cpp
index 21873788a..20298b772 100644
--- a/test/std/utilities/time/time.duration/ratio.fail.cpp
+++ b/test/std/utilities/time/time.duration/ratio.fail.cpp
@@ -22,8 +22,10 @@ public:
     static const int den = D;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<int, Ratio<1> > D;
     D d;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp b/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
index 6331dc95a..8d807c7a9 100644
--- a/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
@@ -20,7 +20,9 @@
 
 typedef std::chrono::duration<unsigned> unsigned_secs;
 
-int main()
+int main(int, char**)
 {
     std::chrono::abs(unsigned_secs(0));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp b/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
index 5cb52ba76..06f9a7c7f 100644
--- a/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
@@ -30,7 +30,7 @@ test(const Duration& f, const Duration& d)
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::milliseconds( 7290000));
@@ -46,4 +46,6 @@ int main()
     constexpr std::chrono::hours h2 = std::chrono::abs(std::chrono::hours(3));
     static_assert(h2.count() == 3, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
index 9d6566a08..d0e47b7fa 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
@@ -25,7 +25,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h(3);
@@ -37,4 +37,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
index 78beffe26..084819af3 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h1(3);
@@ -38,4 +38,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
index 0b8f49fc3..a9d136f79 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::chrono::minutes m(3);
@@ -42,4 +42,6 @@ int main()
     static_assert( (std::is_same< decltype(zero+one), D1>::value), "");
     static_assert( (std::is_same< decltype(+one),     D1>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
index 0e907b573..4247f2d56 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
@@ -28,7 +28,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s(3);
@@ -41,4 +41,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
index c9f1278a3..cfdb7075b 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
@@ -25,7 +25,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h(3);
@@ -37,4 +37,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
index 5abecee16..4afb86e0c 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h1(3);
@@ -39,4 +39,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
index f7ab6d2e2..fe065ff5f 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::chrono::minutes m(3);
@@ -43,4 +43,6 @@ int main()
     static_assert( (std::is_same< decltype(-one),     D1>::value), "");
     static_assert( (std::is_same< decltype(+one),     D1>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
index 1752d5257..b457619e1 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
@@ -28,7 +28,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s(3);
@@ -41,4 +41,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
index 4f79398f7..753ea5a8b 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(15);
@@ -37,4 +37,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
index 89b550d01..649f4aa1a 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
@@ -27,7 +27,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::microseconds us1(11);
@@ -41,4 +41,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
index 8ef16c7ff..0eb73ee67 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::microseconds us(11);
@@ -37,4 +37,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
index b4b76fb6f..51c20c507 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
@@ -26,7 +26,7 @@ constexpr bool test_constexpr()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(3);
@@ -37,4 +37,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
index e557bc21f..a9711f448 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::ceil<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
index b509182c4..a6e1982d0 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
@@ -32,7 +32,7 @@ test(const FromDuration& f, const ToDuration& d)
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 3));
@@ -47,4 +47,6 @@ int main()
     constexpr std::chrono::hours h2 = std::chrono::ceil<std::chrono::hours>(std::chrono::milliseconds(-9000000));
     static_assert(h2.count() == -2, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
index 5187d3d0e..415175676 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
@@ -32,7 +32,7 @@ test(const FromDuration& f, const ToDuration& d)
     }
 }
 
-int main()
+int main(int, char**)
 {
     test(std::chrono::milliseconds(7265000), std::chrono::hours(2));
     test(std::chrono::milliseconds(7265000), std::chrono::minutes(121));
@@ -50,4 +50,6 @@ int main()
     static_assert(h.count() == 2, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
index 62dd5a51d..c119a800c 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::floor<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
index 29142bdcf..6783b1f67 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
@@ -31,7 +31,7 @@ test(const FromDuration& f, const ToDuration& d)
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -46,4 +46,6 @@ int main()
     constexpr std::chrono::hours h2 = std::chrono::floor<std::chrono::hours>(std::chrono::milliseconds(-9000000));
     static_assert(h2.count() == -3, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
index aadfbfdc4..93366b836 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::round<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
index b0789b791..ebd2e3194 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
@@ -31,7 +31,7 @@ test(const FromDuration& f, const ToDuration& d)
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -46,4 +46,6 @@ int main()
     constexpr std::chrono::hours h2 = std::chrono::round<std::chrono::hours>(std::chrono::milliseconds(-9000000));
     static_assert(h2.count() == -2, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
index a46aa526b..0f52c36d8 100644
--- a/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
@@ -18,7 +18,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration_cast<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp b/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
index 912d22fdf..c27b52801 100644
--- a/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -113,4 +113,6 @@ int main()
     static_assert(!(s1 != s2), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp b/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
index 9eea6ceb3..de4763576 100644
--- a/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
@@ -35,7 +35,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -151,4 +151,6 @@ int main()
     static_assert( (s1 >= s2), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
index 0f6fb8d35..4c0af92b2 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::milliseconds ms(1);
@@ -34,4 +34,6 @@ int main()
     static_assert(us.count() == 1000, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
index b35c01c40..4311c1bde 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
@@ -17,8 +17,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<double> d;
     std::chrono::duration<int> i = d;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
index b66b2f3c6..fb0b488f7 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
@@ -17,8 +17,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::microseconds us(1);
     std::chrono::milliseconds ms = us;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
index 5624327ba..f72c69c7e 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::duration<double, std::micro> us(1);
@@ -34,4 +34,6 @@ int main()
     static_assert(ms.count() == 1./1000, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
index a63471bc3..fb127226a 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::duration<int> i(3);
@@ -34,4 +34,6 @@ int main()
     static_assert(d.count() == 3000, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
index 68484d1fb..5b963f2b1 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
@@ -26,11 +26,13 @@ void f(std::chrono::seconds)
     called = true;
 }
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::duration<int, std::exa> r(1);
     f(r);
     assert(called);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
index 9edcd46f9..c598afa36 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
@@ -32,7 +32,9 @@ test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
index f89263bf9..d1a808ba1 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
@@ -31,10 +31,12 @@ test(R r)
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >(5);
     test<std::chrono::duration<int, std::ratio<3, 2> > >(5);
     test<std::chrono::duration<Rep, std::ratio<3, 2> > >(Rep(3));
     test<std::chrono::duration<double, std::ratio<2, 3> > >(5.5);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
index fc6f5700a..f1e60f5e5 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
@@ -19,7 +19,9 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<int> d = 1;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
index bdbe7211b..4a0932506 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
@@ -19,7 +19,9 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d(1);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
index 3ecb76135..1719b1302 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<double> d(5);
     assert(d.count() == 5);
@@ -28,4 +28,6 @@ int main()
     constexpr std::chrono::duration<double> d2(5);
     static_assert(d2.count() == 5, "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
index 831370994..6b4d00203 100644
--- a/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
@@ -17,7 +17,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<int> d(1.);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
index 13ad165b7..0d924f8f7 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::chrono_literals;
 
@@ -57,4 +57,6 @@ int main()
     auto ns2 = 645.ns;
     assert ( ns == ns2 );
 
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
index 025100c59..97e29e876 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
@@ -11,8 +11,10 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::chrono::hours h  = 4h;  // should fail w/conversion operator not found
+
+  return 0;
 }
 
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
index 9ca290867..2e5b7bbb8 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
@@ -11,7 +11,7 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::chrono;
 
@@ -67,4 +67,6 @@ int main()
     assert(November  == month(11));
     assert(December  == month(12));
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
index 5c38db527..dbc915590 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
@@ -11,9 +11,11 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::chrono::hours;
 
     hours foo  =  4h;  // should fail w/conversion operator not found
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
index 407091032..d0b8b33e4 100644
--- a/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
@@ -13,7 +13,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
@@ -46,4 +46,6 @@ int main()
     assert ( ns == std::chrono::nanoseconds(645));
     auto ns2 = 645.ns;
     assert ( ns == ns2 );
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
index 30aa62cd9..ad381f005 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -71,4 +71,6 @@ int main()
     static_assert(r.count() == 75, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
index cb0a53fdf..86ced3fbc 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -72,4 +72,6 @@ int main()
     static_assert(r.count() == -15, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
index 40f521bae..e4190fe33 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "truncate_fp.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns1(15);
@@ -65,4 +65,6 @@ int main()
     static_assert(s1 / s2 == 20./3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
index 41c55fcca..327ff5635 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d(Rep(15));
     d = d / 5;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
index 8718ad757..94da11302 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(15);
@@ -34,4 +34,6 @@ int main()
     static_assert(ns2.count() == 3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
index 7a2063ca5..e7007c1fe 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns1(15);
@@ -60,4 +60,6 @@ int main()
     static_assert(r.count() == 24, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
index 3ee0578f8..f2a5885ab 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d(Rep(15));
     d = d % 5;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
index 6d7e285d9..754b9800a 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(15);
@@ -34,4 +34,6 @@ int main()
     static_assert(ns2.count() == 3, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
index 19e33366f..c3e499638 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(3);
@@ -43,4 +43,6 @@ int main()
     static_assert(ns3.count() == 18, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
index 6ad3c7928..44a77cea1 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
@@ -22,8 +22,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d;
     d = d * 5;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
index 5cc717c5c..9ce82582c 100644
--- a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
@@ -22,8 +22,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d;
     d = 5 * d;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp b/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
index c6f3f1e65..58de66a01 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
@@ -40,8 +40,10 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >();
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
index b16e608dc..9b0113b29 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
@@ -40,8 +40,10 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >();
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
index f3065c305..34a05b5f0 100644
--- a/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
@@ -39,8 +39,10 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >();
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.duration/types.pass.cpp b/test/std/utilities/time/time.duration/types.pass.cpp
index 9e5abbc20..250e53285 100644
--- a/test/std/utilities/time/time.duration/types.pass.cpp
+++ b/test/std/utilities/time/time.duration/types.pass.cpp
@@ -18,9 +18,11 @@
 #include <chrono>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<long, std::ratio<3, 2> > D;
     static_assert((std::is_same<D::rep, long>::value), "");
     static_assert((std::is_same<D::period, std::ratio<3, 2> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/default_duration.pass.cpp b/test/std/utilities/time/time.point/default_duration.pass.cpp
index e645e2970..8a58413a0 100644
--- a/test/std/utilities/time/time.point/default_duration.pass.cpp
+++ b/test/std/utilities/time/time.point/default_duration.pass.cpp
@@ -18,8 +18,10 @@
 #include <chrono>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::chrono::system_clock::duration,
                    std::chrono::time_point<std::chrono::system_clock>::duration>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/duration.fail.cpp b/test/std/utilities/time/time.point/duration.fail.cpp
index a4881acc9..6461eb3d9 100644
--- a/test/std/utilities/time/time.point/duration.fail.cpp
+++ b/test/std/utilities/time/time.point/duration.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::time_point<std::chrono::system_clock, int> T;
     T t;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp b/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
index 999071b72..002fffc38 100644
--- a/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
@@ -29,7 +29,7 @@ constexpr bool constexpr_test()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::chrono::system_clock Clock;
@@ -42,4 +42,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(constexpr_test(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp b/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
index 3d62cdeda..2365d539c 100644
--- a/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
@@ -29,7 +29,7 @@ constexpr bool constexpr_test()
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::chrono::system_clock Clock;
@@ -42,4 +42,6 @@ int main()
 #if TEST_STD_VER > 14
     static_assert(constexpr_test(), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
index 4a90ec870..fb82fdffe 100644
--- a/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::ceil<int>(std::chrono::system_clock::now());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
index efd2a3e59..8dfd1bdaa 100644
--- a/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
@@ -49,7 +49,7 @@ void test_constexpr ()
 }
 
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 3));
@@ -65,4 +65,6 @@ int main()
 
     test_constexpr<std::chrono::milliseconds, 9000000, std::chrono::seconds, 9000> ();
     test_constexpr<std::chrono::milliseconds,-9000000, std::chrono::seconds,-9000> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
index c5dfba6c4..12b1dec9f 100644
--- a/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::floor<int>(std::chrono::system_clock::now());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
index db2391d25..d50fff4a1 100644
--- a/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
@@ -48,7 +48,7 @@ void test_constexpr ()
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -64,4 +64,6 @@ int main()
 
     test_constexpr<std::chrono::milliseconds, 9000000, std::chrono::seconds, 9000> ();
     test_constexpr<std::chrono::milliseconds,-9000000, std::chrono::seconds,-9000> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
index 6c6f9c5bf..a5436c684 100644
--- a/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::round<int>(std::chrono::system_clock::now());
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
index e68e23396..d8bb1b505 100644
--- a/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
@@ -48,7 +48,7 @@ void test_constexpr ()
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -64,4 +64,6 @@ int main()
 
     test_constexpr<std::chrono::milliseconds, 9000000, std::chrono::seconds, 9000> ();
     test_constexpr<std::chrono::milliseconds,-9000000, std::chrono::seconds,-9000> ();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp b/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
index 5779ef920..90e6ccef6 100644
--- a/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
@@ -54,7 +54,7 @@ void test_constexpr ()
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test(std::chrono::milliseconds(7265000), std::chrono::hours(2));
     test(std::chrono::milliseconds(7265000), std::chrono::minutes(121));
@@ -78,4 +78,6 @@ int main()
     test_constexpr<std::chrono::duration<int, std::ratio<2, 3>>, 9, T1, 10> ();
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp b/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
index 9e1f903b9..c16492f73 100644
--- a/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
@@ -18,10 +18,12 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::time_point<Clock, std::chrono::milliseconds> FromTimePoint;
     typedef std::chrono::time_point<Clock, std::chrono::minutes> ToTimePoint;
     std::chrono::time_point_cast<ToTimePoint>(FromTimePoint(std::chrono::milliseconds(3)));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
index e2b3508e0..2b5795026 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
@@ -24,7 +24,7 @@
 
 #include "../../clock.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock1;
     typedef Clock                     Clock2;
@@ -36,4 +36,6 @@ int main()
     T1 t1(Duration1(3));
     T2 t2(Duration2(3000));
     t1 == t2;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
index cc2ef3337..f110ec5d4 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -82,4 +82,6 @@ int main()
     static_assert( (t1 != t2), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
index 04f7639d6..3d158ea89 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
@@ -32,7 +32,7 @@
 
 #include "../../clock.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock1;
     typedef Clock                     Clock2;
@@ -44,4 +44,6 @@ int main()
     T1 t1(Duration1(3));
     T2 t2(Duration2(3000));
     t1 < t2;
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp b/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
index 57d24d08d..3b4aa6abe 100644
--- a/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
@@ -31,7 +31,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -106,4 +106,6 @@ int main()
     static_assert(!(t1 >= t2), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp b/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
index a68d4b0f3..2e601179a 100644
--- a/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
@@ -17,7 +17,7 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -26,4 +26,6 @@ int main()
     std::chrono::time_point<Clock, Duration2> t2(Duration2(3));
     std::chrono::time_point<Clock, Duration1> t1 = t2;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp b/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
index 91bcebb1a..f9b35c957 100644
--- a/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::microseconds Duration1;
@@ -35,4 +35,6 @@ int main()
     static_assert(t1.time_since_epoch() == Duration1(3000), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp b/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
index 2deb8ae29..b40113999 100644
--- a/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::duration<Rep, std::milli> Duration;
@@ -32,4 +32,6 @@ int main()
     static_assert(t.time_since_epoch() == Duration::zero(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp b/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
index 4a42eef30..b28116236 100644
--- a/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
@@ -16,9 +16,11 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
     std::chrono::time_point<Clock, Duration> t = Duration(3);
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp b/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
index 0830eea91..078c6641e 100644
--- a/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
@@ -39,4 +39,6 @@ int main()
     static_assert(t.time_since_epoch() == Duration(3000), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp b/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
index df6c69157..7d78f7f43 100644
--- a/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -44,4 +44,6 @@ int main()
     static_assert(t3.time_since_epoch() == Duration2(3006), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp b/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
index 876d42d56..6fe876969 100644
--- a/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
@@ -30,7 +30,7 @@ void test2739()  // LWG2739
     assert(t1 < t0);
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -49,4 +49,6 @@ int main()
 #endif
     test2739<int32_t>();
     test2739<uint32_t>();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp b/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
index 851869d4d..22e4520f3 100644
--- a/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -36,4 +36,6 @@ int main()
     static_assert((t1 - t2) == Duration2(2995), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp b/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.special/max.pass.cpp b/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
index c8f2d41be..e7826b1a6 100644
--- a/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.special/max.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
@@ -27,4 +27,6 @@ int main()
     ASSERT_NOEXCEPT(       TP::max());
 #endif
     assert(TP::max() == TP(Duration::max()));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.point/time.point.special/min.pass.cpp b/test/std/utilities/time/time.point/time.point.special/min.pass.cpp
index 1cac23062..fae3339b0 100644
--- a/test/std/utilities/time/time.point/time.point.special/min.pass.cpp
+++ b/test/std/utilities/time/time.point/time.point.special/min.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
@@ -27,4 +27,6 @@ int main()
     ASSERT_NOEXCEPT(       TP::max());
 #endif
     assert(TP::min() == TP(Duration::min()));
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp b/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
+++ b/test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp b/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
index f44a7964f..8d244c773 100644
--- a/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::duration_values<int>::max() ==
            std::numeric_limits<int>::max());
@@ -42,4 +42,6 @@ int main()
     ASSERT_NOEXCEPT(std::chrono::duration_values<double>::max());
     ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::max());
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp b/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
index c64746d9f..4ff03c622 100644
--- a/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::duration_values<int>::min() ==
            std::numeric_limits<int>::lowest());
@@ -42,4 +42,6 @@ int main()
     ASSERT_NOEXCEPT(std::chrono::duration_values<double>::min());
     ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::min());
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp b/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
index 6eec47ce3..d9de07b41 100644
--- a/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::duration_values<int>::zero() == 0);
     assert(std::chrono::duration_values<Rep>::zero() == 0);
@@ -31,4 +31,6 @@ int main()
     ASSERT_NOEXCEPT(std::chrono::duration_values<int>::zero());
     ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::zero());
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp b/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
index cf588f5c0..9db3d96d2 100644
--- a/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
@@ -29,7 +29,7 @@ test()
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<unsigned>();
@@ -39,4 +39,6 @@ int main()
     test<double>();
     test<long double>();
     test<A>();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp b/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
index 39afe6a5f..3dde54047 100644
--- a/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
@@ -24,7 +24,7 @@ test()
     static_assert((std::is_same<Dc, De>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int, std::ratio<1, 100> >,
          std::chrono::duration<long, std::ratio<1, 1000> >,
@@ -38,4 +38,6 @@ int main()
     test<std::chrono::duration<double, std::ratio<21, 1> >,
          std::chrono::duration<short, std::ratio<15, 1> >,
          std::chrono::duration<double, std::ratio<3, 1> > >();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp b/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
index bf880fcd2..d73bb8ae6 100644
--- a/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
+++ b/test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
@@ -28,7 +28,7 @@ test()
     static_assert((std::is_same<Tc, Te>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int, std::ratio<1, 100> >,
          std::chrono::duration<long, std::ratio<1, 1000> >,
@@ -42,4 +42,6 @@ int main()
     test<std::chrono::duration<double, std::ratio<21, 1> >,
          std::chrono::duration<short, std::ratio<15, 1> >,
          std::chrono::duration<double, std::ratio<3, 1> > >();
+
+  return 0;
 }
diff --git a/test/std/utilities/time/weeks.pass.cpp b/test/std/utilities/time/weeks.pass.cpp
index 2231c6955..5a0cf3417 100644
--- a/test/std/utilities/time/weeks.pass.cpp
+++ b/test/std/utilities/time/weeks.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::weeks D;
     typedef D::rep Rep;
@@ -24,4 +24,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 22, "");
     static_assert(std::is_same_v<Period, std::ratio_multiply<std::ratio<7>, std::chrono::days::period>>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/time/years.pass.cpp b/test/std/utilities/time/years.pass.cpp
index c2229caee..501636926 100644
--- a/test/std/utilities/time/years.pass.cpp
+++ b/test/std/utilities/time/years.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::years D;
     typedef D::rep Rep;
@@ -24,4 +24,6 @@ int main()
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 17, "");
     static_assert(std::is_same_v<Period, std::ratio_multiply<std::ratio<146097, 400>, std::chrono::days::period>>, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.general/ignore.pass.cpp b/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
index d216c19fc..5d0409a7c 100644
--- a/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
@@ -39,7 +39,7 @@ constexpr bool test_ignore_constexpr()
     return true;
 }
 
-int main() {
+int main(int, char**) {
     {
         constexpr auto& ignore_v = std::ignore;
         ((void)ignore_v);
@@ -50,4 +50,6 @@ int main() {
     {
         LIBCPP_STATIC_ASSERT(std::is_trivial<decltype(std::ignore)>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
index 326d7bb58..d57e7ad18 100644
--- a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
@@ -15,7 +15,7 @@
 #include <tuple>
 #include <memory>
 
-int main () {
+int main(int, char**) {
     {
     std::tuple<std::unique_ptr<char>> up;
     std::tuple<std::shared_ptr<char>> sp;
@@ -29,4 +29,6 @@ int main () {
     // Smart pointers of type 'T[N]' are not tested here since they are not
     // supported by the standard nor by libc++'s implementation.
     // See https://reviews.llvm.org/D21320 for more information.
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
index b9e6e111c..27f3d5934 100644
--- a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
@@ -25,11 +25,13 @@ struct X
     void operator()() {}
 };
 
-int main()
+int main(int, char**)
 {
     X x;
     std::function<void()> f(x);
+
+  return 0;
 }
 #else
-int main () {}
+int main(int, char**) { return 0; }
 #endif
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
index 2daef09fb..52e94cc0b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
@@ -265,9 +265,11 @@ void test_return_type()
     test<13, int const volatile *>();
 }
 
-int main() {
+int main(int, char**) {
     test_constexpr_evaluation();
     test_call_quals_and_arg_types();
     test_return_type();
     test_noexcept();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
index 978c923ef..851a535eb 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
@@ -360,7 +360,7 @@ void test_ext_int_2()
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         test_ext_int_0<
@@ -422,4 +422,6 @@ int main()
           , std::tuple<A_base_2, int, int>, std::tuple<A_base_2 const, int, int>
           >();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
index 138f074b2..004a5d464 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
@@ -129,7 +129,7 @@ void test_one()
     }
 }
 
-int main()
+int main(int, char**)
 {
     // Instantiate with 1-5 arguments.
     test_all<1>();
@@ -140,4 +140,6 @@ int main()
 
     // Stress test with 256
     test_one<256>();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
index 6afd88825..53574ee1d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
@@ -205,9 +205,11 @@ void test_noexcept() {
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_constexpr_construction();
     test_perfect_forwarding();
     test_noexcept();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
index bf4a8cc0d..9353add37 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
@@ -19,7 +19,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, char> T0;
@@ -30,4 +30,6 @@ int main()
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == short('a'));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
index e21118a2f..8b9447c99 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
@@ -32,7 +32,7 @@ struct D
     explicit D(int i = 0) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -85,4 +85,6 @@ int main()
         assert(std::get<0>(t) == 43);
         assert(&std::get<0>(t) == &x);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
index 95b1e2769..71855a309 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
@@ -43,7 +43,7 @@ struct E {
   }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -106,4 +106,6 @@ int main()
         assert(std::get<0>(t) == 43);
         assert(&std::get<0>(t) == &x);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
index 167d442b7..c3fa6495f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<MoveOnly> T;
@@ -27,4 +27,6 @@ int main()
         T t;
         t = t0;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
index 5162c4053..f6ff1041e 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
@@ -35,7 +35,7 @@ struct MoveAssignable {
   MoveAssignable& operator=(MoveAssignable&&) = default;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -100,4 +100,6 @@ int main()
         using T = std::tuple<int, MoveAssignable>;
         static_assert(!std::is_copy_assignable<T>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
index 4545cf4df..575c3b1df 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
@@ -48,7 +48,7 @@ int CountAssign::copied = 0;
 int CountAssign::moved = 0;
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -122,4 +122,6 @@ int main()
         assert(CountAssign::copied == 1);
         assert(CountAssign::moved == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
index 2dec9fffa..9681a238a 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
@@ -35,7 +35,7 @@ struct D
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, std::unique_ptr<D>> T0;
@@ -46,4 +46,6 @@ int main()
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
index 5e31090c9..5796e8dbe 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
@@ -25,9 +25,11 @@
 typedef std::array<char, 1256> array_t;
 typedef std::tuple<array_t> tuple_t;
 
-int main()
+int main(int, char**)
 {
     array_t arr;
     tuple_t tup;
     tup = arr;
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
index b6e444c65..973aa93df 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
@@ -131,7 +131,9 @@ void allocator_tests() {
 }
 
 
-int main() {
+int main(int, char**) {
   compile_tests();
   allocator_tests();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
index 79064fb09..1e1b0846c 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
@@ -78,7 +78,7 @@ struct ConvertibleFromInt {
   ConvertibleFromInt(int) : state(FromInt) {}
 };
 
-int main()
+int main(int, char**)
 {
     // Test for the creation of dangling references when a tuple is used to
     // store a reference to another tuple as its only element.
@@ -174,4 +174,6 @@ int main()
         std::tuple<VT> t2 = {t1};
         assert(std::get<0>(t2).state == VT::FromInt);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
index 8992f7b82..919d88e46 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
@@ -57,7 +57,7 @@ struct ExplicitUnconstrainedCtor {
 
 };
 
-int main() {
+int main(int, char**) {
     typedef UnconstrainedCtor A;
     typedef ExplicitUnconstrainedCtor ExplicitA;
     {
@@ -94,4 +94,6 @@ int main() {
         std::tuple<ExplicitA&&> t2(std::forward_as_tuple(ExplicitA{}));
         ((void)t2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
index 9f8658aa6..1493f4f81 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
@@ -29,7 +29,7 @@ extern IncompleteType inc2;
 IncompleteType const& cinc1 = inc1;
 IncompleteType const& cinc2 = inc2;
 
-int main() {
+int main(int, char**) {
     using IT = IncompleteType;
     { // try calling tuple(Tp const&...)
         using Tup = std::tuple<const IT&, const IT&>;
@@ -43,6 +43,8 @@ int main() {
         assert(&std::get<0>(t) == &inc1);
         assert(&std::get<1>(t) == &inc2);
     }
+
+  return 0;
 }
 
 struct IncompleteType {};
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
index b0dd392f1..6c44f7027 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
@@ -44,7 +44,7 @@ struct ExplicitDerived : std::tuple<T> {
   explicit operator std::tuple<U>() && { ++count; return {}; }
 };
 
-int main() {
+int main(int, char**) {
   {
     std::tuple<Explicit> foo = Derived<int>{42}; ((void)foo);
     assert(count == 1);
@@ -84,4 +84,6 @@ int main() {
   }
   count = 0;
 
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
index 3a0e0f888..3b9d0beea 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
@@ -42,9 +42,11 @@ public:
     bool operator< (const MoveOnly& x) const {return data_ <  x.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<MoveOnly> t = 1;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
index f43e6d8bc..916255c96 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
@@ -102,7 +102,7 @@ void test_default_constructible_extension_sfinae()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<MoveOnly> t(MoveOnly(0));
@@ -156,4 +156,6 @@ int main()
     // Check that SFINAE is properly applied with the default reduced arity
     // constructor extensions.
     test_default_constructible_extension_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
index e4ed47690..c5f52a928 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
@@ -39,7 +39,7 @@ struct NonDefaultConstructible {
 
 struct DerivedFromAllocArgT : std::allocator_arg_t {};
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<> t(std::allocator_arg, A1<int>());
@@ -105,4 +105,6 @@ int main()
         std::tuple<T, T> t2(42, 42);
         (void)t2;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
index 99155823b..57e2f1b41 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
@@ -77,7 +77,7 @@ struct Explicit {
   explicit Explicit(int x) : value(x) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<Explicit> t{std::allocator_arg, std::allocator<void>{}, 42};
@@ -148,4 +148,6 @@ int main()
     // ensure that the "reduced-arity-initialization" extension is not offered
     // for these constructors.
     test_uses_allocator_sfinae_evaluation();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
index 1759ba4f3..76f99e197 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
@@ -35,8 +35,10 @@ std::tuple<ExplicitCopy> non_const_explicity_copy_test() {
     return {std::allocator_arg, std::allocator<void>{}, e};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
-int main()
+int main(int, char**)
 {
     const_explicit_copy_test();
     non_const_explicity_copy_test();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
index 10647a49d..3b5b27f7b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
@@ -40,7 +40,7 @@ std::tuple<ImplicitCopy> testImplicitCopy2() {
     return {std::allocator_arg, std::allocator<void>{}, i};
 }
 
-int main()
+int main(int, char**)
 {
     {
         // check that the literal '0' can implicitly initialize a stored pointer.
@@ -94,4 +94,6 @@ int main()
         assert(!alloc_last::allocator_constructed);
         assert(std::get<2>(t) == alloc_last(3));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
index baafee879..a7cffa72d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
@@ -23,7 +23,7 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, int> T0;
@@ -55,4 +55,6 @@ int main()
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
index 8d0482859..ca9518d6b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
@@ -36,7 +36,9 @@ std::tuple<ExplicitCopy> non_const_explicit_copy_test() {
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
-int main()
+int main(int, char**)
 {
 
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
index bcece6098..083e15797 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
@@ -33,7 +33,7 @@ struct Implicit {
   Implicit(int x) : value(x) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -86,4 +86,6 @@ int main()
         std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, t1};
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
index ed485c901..7a2a5ffff 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
@@ -29,7 +29,9 @@ std::tuple<ExplicitCopy> explicit_move_test() {
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
-int main()
+int main(int, char**)
 {
 
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
index e86ec8aea..1f33ef2fc 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
@@ -49,7 +49,7 @@ struct Implicit {
   Implicit(int x) : value(x) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int> T0;
@@ -100,4 +100,6 @@ int main()
         std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, std::move(t1)};
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
index 19829a967..1db842b8d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
@@ -22,7 +22,7 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -77,4 +77,6 @@ int main()
         assert(std::get<2>(t) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
index c77484de5..fc25a4fc6 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
@@ -23,7 +23,7 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -76,4 +76,6 @@ int main()
         assert(std::get<2>(t) == 3);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
index 3da2d8a46..e45702d88 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
@@ -39,7 +39,7 @@ struct D
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, std::unique_ptr<D>> T0;
@@ -51,4 +51,6 @@ int main()
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
index 2a405c1a4..bb7c55735 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
@@ -42,6 +42,8 @@ std::tuple<ExplicitCopy> const_explicit_copy_no_brace() {
     // expected-error@-1 {{no viable conversion}}
 }
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
index 955a83a6e..d4c29c93c 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
@@ -76,7 +76,7 @@ std::tuple<ImplicitCopy> testImplicitCopy3() {
     return i;
 }
 
-int main()
+int main(int, char**)
 {
     {
         // check that the literal '0' can implicitly initialize a stored pointer.
@@ -159,4 +159,6 @@ int main()
         assert(std::get<3>(t) == 0.0);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
index 35e82277f..8804c27b8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
@@ -18,9 +18,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<int, char*, std::string, double&> t(2, nullptr, "text");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
index 0fd29b22f..bbe51e392 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, char> T0;
@@ -42,4 +42,6 @@ int main()
         static_assert(std::get<1>(t1) == short('a'), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
index 98d002b80..41f73328a 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
@@ -64,7 +64,7 @@ struct C
 
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -136,4 +136,6 @@ int main()
         std::tuple<Implicit> t2 = t1;
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
index 79332841e..071f13cf9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
@@ -44,7 +44,7 @@ struct D
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -100,4 +100,6 @@ int main()
         std::tuple<Implicit> t2 = std::move(t1);
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
index f82dc6b1f..7eeb65a8f 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
@@ -19,11 +19,13 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<MoveOnly> T;
         T t0(MoveOnly(2));
         T t = t0;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
index 7c581cb77..012781304 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
@@ -22,7 +22,7 @@
 
 struct Empty {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -66,4 +66,6 @@ int main()
         ((void)e); // Prevent unused warning
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
index 15bcde7e9..ae296f739 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
@@ -44,7 +44,7 @@ struct IllFormedDefault {
     int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<> t;
@@ -106,4 +106,6 @@ int main()
         IllFormedDefault v(0);
         std::tuple<IllFormedDefault> t(v);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
index 1d4779aae..80b09b871 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
   static_assert(std::is_trivially_destructible<
       std::tuple<> >::value, "");
@@ -35,4 +35,6 @@ int main()
       std::tuple<std::string> >::value, "");
   static_assert(!std::is_trivially_destructible<
       std::tuple<int, std::string> >::value, "");
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
index ea393abaf..3ff089a0b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
@@ -149,7 +149,9 @@ void test_empty_specialization()
   }
 }
 
-int main() {
+int main(int, char**) {
   test_primary_template();
   test_empty_specialization();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
index 98a12a972..977dc4c32 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
@@ -80,7 +80,7 @@ void test_sfinae() {
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -121,4 +121,6 @@ int main()
         test_sfinae<move_only_ebo>();
         test_sfinae<move_only_large>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
index 3953ee150..635be614b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
@@ -34,7 +34,7 @@ struct D
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, std::unique_ptr<D>> T0;
@@ -44,4 +44,6 @@ int main()
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
index 248685156..bdbe4fc4b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
@@ -95,7 +95,9 @@ void test_const_Types_lazy_sfinae()
     assert(std::get<0>(t).value == 42);
 }
 
-int main() {
+int main(int, char**) {
     test_tuple_like_lazy_sfinae();
     test_const_Types_lazy_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
index b84dba378..2f9447f2a 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
@@ -28,8 +28,10 @@
 typedef std::array<char, 1256> array_t;
 typedef std::tuple<array_t> tuple_t;
 
-int main()
+int main(int, char**)
 {
     array_t arr;
     tuple_t tup(arr);
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
index 5a7940da6..8dc1e48f8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
@@ -64,7 +64,7 @@ test3(const Tuple&)
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         test0(std::forward_as_tuple());
@@ -84,4 +84,6 @@ int main()
         static_assert ( test3 (std::forward_as_tuple(i, c)) == 2, "" );
 #endif
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
index 3f0dae093..444e978b0 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         int i = 0;
@@ -50,4 +50,6 @@ int main()
         static_assert (d1 == 3.14, "" );
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
index f703ef2c8..53ccc23b9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
@@ -39,7 +39,7 @@ constexpr bool test_tie_constexpr() {
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int i = 0;
@@ -60,4 +60,6 @@ int main()
         static_assert(test_tie_constexpr(), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
index 927fc2ab8..40efbd1b8 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<> t = std::tuple_cat();
@@ -238,4 +238,6 @@ int main()
         );
         assert(t2 == std::make_tuple(std::make_tuple(1), std::make_tuple(2)));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
index 4c0b5a6b4..650303ff7 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<double&, std::string, int> T;
@@ -37,4 +37,6 @@ int main()
 
         std::get<1>(t) = "four";
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
index 5ca0bd8e9..a280c500b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
@@ -24,7 +24,7 @@
 
 struct Empty {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int> T;
@@ -64,4 +64,6 @@ int main()
         assert(std::get<2>(t) == 5);
         assert(d == 2.5);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
index 373d84bad..cf0e88246 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
@@ -23,11 +23,13 @@ template <class T> void cref(T const&&) = delete;
 
 std::tuple<int> const tup4() { return std::make_tuple(4); }
 
-int main()
+int main(int, char**)
 {
     // LWG2485: tuple should not open a hole in the type system, get() should
     // imitate [expr.ref]'s rules for accessing data members
     {
         cref(std::get<0>(tup4()));  // expected-error {{call to deleted function 'cref'}}
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
index 4c2654cd7..5801d5a5e 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::tuple<int> T;
@@ -76,4 +76,6 @@ int main()
     static_assert(std::get<1>(std::move(t)) == 5, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
index 3708e5cb0..3cbf01b25 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
@@ -36,7 +36,7 @@ struct S {
 constexpr std::tuple<int, int> getP () { return { 3, 4 }; }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int> T;
@@ -81,4 +81,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
index 114672b7c..ae968403b 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
@@ -21,7 +21,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<std::unique_ptr<int> > T;
@@ -29,4 +29,6 @@ int main()
         std::unique_ptr<int> p = std::get<0>(std::move(t));
         assert(*p == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
index f85c8098f..51bf1d550 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
@@ -31,8 +31,10 @@ void test_bad_return_type() {
     upint p = std::get<upint>(t); // expected-error{{deleted copy constructor}}
 }
 
-int main()
+int main(int, char**)
 {
     test_bad_index();
     test_bad_return_type();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
index 9df8ce381..7dd4e8f10 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     {
@@ -90,4 +90,6 @@ int main()
     static_assert(std::get<int>(std::move(t)) == 1, "");
     static_assert(std::get<const int>(std::move(t)) == 2, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
index e56f86a1c..a97e60ca7 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
@@ -40,7 +40,7 @@ void test()
     static_assert((std::is_same<typename std::tuple_element<idx, const volatile T>::type, const volatile U>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::array<int, 5>, 5, int, 0>();
     test<std::array<int, 5>, 5, int, 1>();
@@ -48,4 +48,6 @@ int main()
     test<std::array<volatile int, 4>, 4, volatile int, 3>();
     test<std::array<char *, 3>, 3, char *, 1>();
     test<std::array<char *, 3>, 3, char *, 2>();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
index eb1704c94..fdfb8b8b0 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
@@ -38,7 +38,7 @@ void test()
     static_assert((std::is_same<typename std::tuple_element<idx, const volatile T>::type, const volatile U>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::pair<int, int>, 2, int, 0>();
     test<std::pair<int, int>, 2, int, 1>();
@@ -46,4 +46,6 @@ int main()
     test<std::pair<int, volatile int>, 2, volatile int, 1>();
     test<std::pair<char *, int>, 2, char *, 0>();
     test<std::pair<char *, int>, 2, int,    1>();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
index a1c42921b..24b735b7e 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
@@ -22,7 +22,7 @@
 #include <tuple>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     using T =  std::tuple<int, long, void*>;
     using E1 = typename std::tuple_element<1, T &>::type; // expected-error{{undefined template}}
@@ -30,4 +30,6 @@ int main()
     using E3 = typename std::tuple_element<4, T const>::type;
         // expected-error@__tuple:* 2 {{static_assert failed}}
 
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
index ecb6ea087..5ad2b0822 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
@@ -39,7 +39,7 @@ void test()
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::tuple<int>, 0, int>();
     test<std::tuple<char, int>, 0, char>();
@@ -47,4 +47,6 @@ int main()
     test<std::tuple<int*, char, int>, 0, int*>();
     test<std::tuple<int*, char, int>, 1, char>();
     test<std::tuple<int*, char, int>, 2, int>();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
index aa2081839..9b065b3b9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
@@ -18,9 +18,11 @@
 
 #include <tuple>
 
-int main()
+int main(int, char**)
 {
     (void)std::tuple_size<std::tuple<> &>::value; // expected-error {{implicit instantiation of undefined template}}
     (void)std::tuple_size<int>::value; // expected-error {{implicit instantiation of undefined template}}
     (void)std::tuple_size<std::tuple<>*>::value; // expected-error {{implicit instantiation of undefined template}}
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
index 2a602b1ca..f27c7eb47 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
@@ -32,10 +32,12 @@ void test()
                                    std::tuple_size<const volatile T> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::tuple<>, 0>();
     test<std::tuple<int>, 1>();
     test<std::tuple<char, int>, 2>();
     test<std::tuple<char, char*, int>, 3>();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
index 3d0925068..83b773abf 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
@@ -39,7 +39,7 @@ public:
 template <>
 struct std::tuple_size<Dummy3> {};
 
-int main()
+int main(int, char**)
 {
   // Test that tuple_size<const T> is not incomplete when tuple_size<T>::value
   // is well-formed but not a constant expression.
@@ -59,4 +59,6 @@ int main()
     // expected-error@__tuple:* 1 {{no member named 'value'}}
     (void)std::tuple_size<const Dummy3>::value; // expected-note {{here}}
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
index 44e100c6d..32bad3317 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
@@ -50,7 +50,7 @@ void test_incomplete() {
 }
 
 
-int main()
+int main(int, char**)
 {
   test_complete<std::tuple<> >();
   test_complete<std::tuple<int&> >();
@@ -63,4 +63,6 @@ int main()
   test_incomplete<int>();
   test_incomplete<std::tuple<int>&>();
   test_incomplete<Dummy2>();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
index f191f9f64..00f7ff269 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
@@ -139,11 +139,13 @@ void test_after_tuple_size_specialization() {
   assert(p == -1);
 }
 
-int main() {
+int main(int, char**) {
   test_decomp_user_type();
   test_decomp_tuple();
   test_decomp_pair();
   test_decomp_array();
   test_before_tuple_size_specialization();
   test_after_tuple_size_specialization();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
index 820cb0443..8bd3fbd57 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
@@ -16,10 +16,12 @@
 
 #include <tuple>
 
-int main()
+int main(int, char**)
 {
     (void)std::tuple_size_v<std::tuple<> &>; // expected-note {{requested here}}
     (void)std::tuple_size_v<int>; // expected-note {{requested here}}
     (void)std::tuple_size_v<std::tuple<>*>; // expected-note {{requested here}}
     // expected-error@tuple:* 3 {{implicit instantiation of undefined template}}
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
index b2b3e72b9..bd01f4949 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
@@ -26,7 +26,7 @@ void test()
     static_assert(std::tuple_size_v<Tuple const volatile> == std::tuple_size<Tuple>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::tuple<>, 0>();
 
@@ -39,4 +39,6 @@ int main()
 
     test<std::tuple<int, int, int>, 3>();
     test<std::array<int, 3>, 3>();
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
index 9c0041876..2efbfa50e 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
@@ -27,7 +27,7 @@ template <class T> constexpr bool has_value() { return has_value<T>(0); }
 
 struct Dummy {};
 
-int main() {
+int main(int, char**) {
   // Test that the ::value member does not exist
   static_assert(has_value<std::tuple<int> const>(), "");
   static_assert(has_value<std::pair<int, long> volatile>(), "");
@@ -35,4 +35,6 @@ int main() {
   static_assert(!has_value<const int>(), "");
   static_assert(!has_value<volatile void>(), "");
   static_assert(!has_value<const volatile std::tuple<int>&>(), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
index 709f747c7..0302c839e 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T1;
@@ -154,4 +154,6 @@ int main()
         static_assert(t1 != t2, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
index 9f29c6c4a..64ed9b4a9 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
@@ -34,7 +34,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T1;
@@ -208,4 +208,6 @@ int main()
         static_assert(!(t1 >= t2), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
index 079977016..eee8f1819 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -58,4 +58,6 @@ int main()
         assert(std::get<1>(t1) == 1);
         assert(std::get<2>(t1) == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
index 097f69b42..951a88726 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -57,4 +57,6 @@ int main()
         assert(std::get<1>(t1) == 1);
         assert(std::get<2>(t1) == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
index 5e4722874..b04c491ed 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
@@ -20,7 +20,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -42,4 +42,6 @@ int main()
         static_assert((std::is_base_of<std::true_type,
                                        std::uses_allocator<T, A>>::value), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp b/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
index daa287e3e..710b33878 100644
--- a/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.hash/hash.pass.cpp b/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
index 139847fda..8192a9020 100644
--- a/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
+++ b/test/std/utilities/type.index/type.index.hash/hash.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::hash<std::type_index> H;
     static_assert((std::is_same<typename H::argument_type, std::type_index>::value), "" );
@@ -29,4 +29,6 @@ int main()
 
     std::type_index t1 = typeid(int);
     assert(std::hash<std::type_index>()(t1) == t1.hash_code());
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.members/ctor.pass.cpp b/test/std/utilities/type.index/type.index.members/ctor.pass.cpp
index cafeebb09..c133130f1 100644
--- a/test/std/utilities/type.index/type.index.members/ctor.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/ctor.pass.cpp
@@ -16,9 +16,11 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_info const & info = typeid(int);
     std::type_index t1(info);
     assert(t1.name() == info.name());
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.members/eq.pass.cpp b/test/std/utilities/type.index/type.index.members/eq.pass.cpp
index 210d0ab02..97f6448b7 100644
--- a/test/std/utilities/type.index/type.index.members/eq.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/eq.pass.cpp
@@ -16,11 +16,13 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1 = typeid(int);
     std::type_index t2 = typeid(int);
     std::type_index t3 = typeid(long);
     assert(t1 == t2);
     assert(t1 != t3);
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp b/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
index f5b6cc35c..0619ff754 100644
--- a/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
@@ -15,9 +15,11 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::type_info& ti = typeid(int);
     std::type_index t1 = typeid(int);
     assert(t1.hash_code() == ti.hash_code());
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.members/lt.pass.cpp b/test/std/utilities/type.index/type.index.members/lt.pass.cpp
index 1f631b7b9..e24b3975e 100644
--- a/test/std/utilities/type.index/type.index.members/lt.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/lt.pass.cpp
@@ -18,7 +18,7 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1 = typeid(int);
     std::type_index t2 = typeid(int);
@@ -41,4 +41,6 @@ int main()
         assert( (t1 >  t3));
         assert( (t1 >= t3));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.members/name.pass.cpp b/test/std/utilities/type.index/type.index.members/name.pass.cpp
index 1b01f52f9..ee91629b3 100644
--- a/test/std/utilities/type.index/type.index.members/name.pass.cpp
+++ b/test/std/utilities/type.index/type.index.members/name.pass.cpp
@@ -16,9 +16,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::type_info& ti = typeid(int);
     std::type_index t1 = typeid(int);
     assert(std::string(t1.name()) == ti.name());
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp b/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
index b7fbb6f91..72cae39d0 100644
--- a/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
+++ b/test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
@@ -15,11 +15,13 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1(typeid(int));
     std::type_index t2(typeid(double));
     assert(t2 != t1);
     t2 = t1;
     assert(t2 == t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp b/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
index 9520cd8f6..df0df2e8c 100644
--- a/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
+++ b/test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
@@ -15,9 +15,11 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1(typeid(int));
     std::type_index t2 = t1;
     assert(t2 == t1);
+
+  return 0;
 }
diff --git a/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp b/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
index 333e04b18..e8ce292cc 100644
--- a/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
+++ b/test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
@@ -22,7 +22,7 @@
 #include "poisoned_hash_helper.hpp"
 #endif
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::hash<std::type_index> H;
@@ -34,4 +34,6 @@ int main()
     test_hash_enabled_for_type<std::type_index>(std::type_index(typeid(int)));
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utilities.general/nothing_to_do.pass.cpp b/test/std/utilities/utilities.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utilities.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utilities.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp b/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/as_const/as_const.fail.cpp b/test/std/utilities/utility/as_const/as_const.fail.cpp
index 5f3b78b72..1bb2e64c3 100644
--- a/test/std/utilities/utility/as_const/as_const.fail.cpp
+++ b/test/std/utilities/utility/as_const/as_const.fail.cpp
@@ -15,7 +15,9 @@
 
 struct S {int i;};
 
-int main()
+int main(int, char**)
 {
     std::as_const(S{});
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/as_const/as_const.pass.cpp b/test/std/utilities/utility/as_const/as_const.pass.cpp
index 284e5b7b3..32d240a0b 100644
--- a/test/std/utilities/utility/as_const/as_const.pass.cpp
+++ b/test/std/utilities/utility/as_const/as_const.pass.cpp
@@ -34,7 +34,7 @@ void test(T& t)
     assert(std::as_const<const volatile T>(t) == t);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 3;
     double d = 4.0;
@@ -42,4 +42,6 @@ int main()
     test(i);
     test(d);
     test(s);
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/declval/declval.pass.cpp b/test/std/utilities/utility/declval/declval.pass.cpp
index b298d58a0..6509fd437 100644
--- a/test/std/utilities/utility/declval/declval.pass.cpp
+++ b/test/std/utilities/utility/declval/declval.pass.cpp
@@ -21,11 +21,13 @@ class A
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<decltype(std::declval<A>()), A&&>::value), "");
 #else
     static_assert((std::is_same<decltype(std::declval<A>()), A&>::value), "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/exchange/exchange.pass.cpp b/test/std/utilities/utility/exchange/exchange.pass.cpp
index 1defcbfb3..41e8abb43 100644
--- a/test/std/utilities/utility/exchange/exchange.pass.cpp
+++ b/test/std/utilities/utility/exchange/exchange.pass.cpp
@@ -39,7 +39,7 @@ TEST_CONSTEXPR bool test_constexpr() {
 
 
 
-int main()
+int main(int, char**)
 {
     {
     int v = 12;
@@ -80,4 +80,6 @@ int main()
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/forward/forward.fail.cpp b/test/std/utilities/utility/forward/forward.fail.cpp
index a689b1d0d..4efc1b6aa 100644
--- a/test/std/utilities/utility/forward/forward.fail.cpp
+++ b/test/std/utilities/utility/forward/forward.fail.cpp
@@ -19,7 +19,7 @@ struct A
 A source() {return A();}
 const A csource() {return A();}
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -49,4 +49,6 @@ int main()
         A a;
         std::forward(a); // expected-error {{no matching function for call to 'forward'}}
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/forward/forward.pass.cpp b/test/std/utilities/utility/forward/forward.pass.cpp
index 394c016e2..b2f7c9603 100644
--- a/test/std/utilities/utility/forward/forward.pass.cpp
+++ b/test/std/utilities/utility/forward/forward.pass.cpp
@@ -41,7 +41,7 @@ constexpr bool test_constexpr_forward() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     A a;
     const A ca = A();
@@ -87,4 +87,6 @@ int main()
     static_assert(std::forward<const int&>(i2) == 42, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/forward/forward_03.pass.cpp b/test/std/utilities/utility/forward/forward_03.pass.cpp
index c5a2507a7..522382dc7 100644
--- a/test/std/utilities/utility/forward/forward_03.pass.cpp
+++ b/test/std/utilities/utility/forward/forward_03.pass.cpp
@@ -28,7 +28,7 @@ struct eight {one _[8];};
 one test(A&);
 two test(const A&);
 
-int main()
+int main(int, char**)
 {
     A a;
     const A ca = A();
@@ -54,4 +54,6 @@ int main()
     static_assert(sizeof(test(std::forward<const A>(ca))) == 2, "");
     static_assert(sizeof(test(std::forward<const A>(csource()))) == 2, "");
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/forward/move.fail.cpp b/test/std/utilities/utility/forward/move.fail.cpp
index bd8fd46a9..86f3cc3e5 100644
--- a/test/std/utilities/utility/forward/move.fail.cpp
+++ b/test/std/utilities/utility/forward/move.fail.cpp
@@ -24,10 +24,12 @@ const move_only csource() {return move_only();}
 
 void test(move_only) {}
 
-int main()
+int main(int, char**)
 {
     move_only a;
     const move_only ca = move_only();
 
     test(std::move(ca)); // c
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/forward/move.pass.cpp b/test/std/utilities/utility/forward/move.pass.cpp
index c98efa1c3..3db61cda2 100644
--- a/test/std/utilities/utility/forward/move.pass.cpp
+++ b/test/std/utilities/utility/forward/move.pass.cpp
@@ -62,7 +62,7 @@ constexpr bool test_constexpr_move() {
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     { // Test return type and noexcept.
         static_assert(std::is_same<decltype(std::move(x)), int&&>::value, "");
@@ -117,4 +117,6 @@ int main()
         static_assert(std::move(y) == 42, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp b/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
index 52a276c24..11ea3c58f 100644
--- a/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
+++ b/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
@@ -39,7 +39,7 @@ struct legacy
     legacy(const legacy&);
 };
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     const int ci = 0;
@@ -71,4 +71,6 @@ int main()
     static_assert(i2 == 23, "" );
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/operators/rel_ops.pass.cpp b/test/std/utilities/utility/operators/rel_ops.pass.cpp
index 9c8dbedcc..42e808665 100644
--- a/test/std/utilities/utility/operators/rel_ops.pass.cpp
+++ b/test/std/utilities/utility/operators/rel_ops.pass.cpp
@@ -32,7 +32,7 @@ operator < (const A& x, const A& y)
     return x.data_ < y.data_;
 }
 
-int main()
+int main(int, char**)
 {
     using namespace std::rel_ops;
     A a1(1);
@@ -45,4 +45,6 @@ int main()
     assert(a1 <= a2);
     assert(a2 >= a2);
     assert(a2 >= a1);
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp b/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
index e14a1c46a..e186514f0 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -26,4 +26,6 @@ int main()
         assert(std::get<1>(p) == 4);
         std::get<0>(p) = 5;
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
index 2b164deb4..d9747b337 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -36,4 +36,6 @@ int main()
         static_assert(std::get<1>(p1) == 4, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
index 05c81a23b..a477c5150 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<std::unique_ptr<int>, short> P;
@@ -62,4 +62,6 @@ int main()
     static_assert(std::get<1>(std::move(p1)) == 4, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
index 45fb7aa79..6119cd5c8 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
@@ -29,7 +29,7 @@ struct S {
 constexpr std::pair<int, int> getP () { return { 3, 4 }; }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -49,4 +49,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
index 9ca7b4df6..e0ce55bba 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<int>, short> P;
@@ -28,4 +28,6 @@ int main()
         std::unique_ptr<int> ptr = std::get<0>(std::move(p));
         assert(*ptr == 3);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
index 99fb2cd22..f2d3359e7 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
@@ -16,7 +16,7 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     {
@@ -81,4 +81,6 @@ int main()
     static_assert(std::get<int>(std::move(p)) == 1, "");
     static_assert(std::get<const int>(std::move(p)) == 2, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
index bba71cb8d..dce209921 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
@@ -12,9 +12,11 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     auto t1 = std::make_pair<int, double> ( 42, 3.4 );
     assert (( std::get<cf>(t1) == cf {1,2} ));  // no such type
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
index c79e0788c..4c2ea88e6 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
@@ -12,9 +12,11 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     auto t1 = std::make_pair<int, int> ( 42, 43 );
     assert ( std::get<int>(t1) == 42 ); // two ints
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
index 4787d0e2e..e30b787e1 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
@@ -12,9 +12,11 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::unique_ptr<int> upint;
     std::pair<upint, int> t(upint(new int(4)), 23);
     upint p = std::get<upint>(t);
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
index ba571fda1..e53ca898d 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<int, short> T;
     std::tuple_element<2, T>::type foo; // expected-error@utility:* {{Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
index 4ba581434..1e41e3fda 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
@@ -47,8 +47,10 @@ void test()
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<int, short>();
     test<int*, char>();
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
index a88b84596..3b95b4749 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -32,4 +32,6 @@ int main()
         typedef std::pair<int, short> const volatile P1;
         static_assert((std::tuple_size<P1>::value == 2), "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp b/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
index 72eb31208..98f864caf 100644
--- a/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
+++ b/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
@@ -41,7 +41,7 @@ public:
     unsigned get_u2() const {return u2_;}
 };
 
-int main()
+int main(int, char**)
 {
     std::pair<A, B> p(std::piecewise_construct,
                       std::make_tuple(4, 'a'),
@@ -51,4 +51,6 @@ int main()
     assert(p.second.get_d() == 3.5);
     assert(p.second.get_u1() == 6u);
     assert(p.second.get_u2() == 2u);
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp b/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
index f77636c84..1f764da05 100644
--- a/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
index 11403c91d..0f22808de 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
@@ -46,7 +46,7 @@ struct ImplicitT {
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<int>, short*> P;
@@ -96,4 +96,6 @@ int main()
         static_assert(p.second.value == 43, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
index 5af432b99..834d73dd7 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
@@ -20,7 +20,7 @@
 #include "archetypes.hpp"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -48,4 +48,6 @@ int main()
        assert(p.second.value == -42);
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
index db671a150..f4dfe5e1b 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
@@ -49,7 +49,7 @@ int CountAssign::moved = 0;
 struct Incomplete;
 extern Incomplete inc_obj;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<CopyAssignable, short> P;
@@ -94,6 +94,8 @@ int main()
         P p(42, inc_obj);
         assert(&p.second == &inc_obj);
     }
+
+  return 0;
 }
 
 struct Incomplete {};
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
index 53cc49183..47f85eaa6 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
@@ -27,7 +27,7 @@ private:
 struct Incomplete;
 extern Incomplete inc_obj;
 
-int main()
+int main(int, char**)
 {
     {
     // Test that we don't constrain the assignment operator in C++03 mode.
@@ -42,6 +42,8 @@ int main()
     P p(42, inc_obj);
     assert(&p.second == &inc_obj);
     }
+
+  return 0;
 }
 
 struct Incomplete {};
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
index 91427ca7f..b4f0c0109 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
@@ -45,7 +45,7 @@ struct CountAssign {
 int CountAssign::copied = 0;
 int CountAssign::moved = 0;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<int>, int> P;
@@ -92,4 +92,6 @@ int main()
         assert(CountAssign::moved == 1);
         assert(CountAssign::copied == 0);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
index 7248c2ffa..0be0a4e95 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
@@ -29,7 +29,7 @@ struct Derived
 {
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<Derived>, short> P1;
@@ -55,4 +55,6 @@ int main()
        assert(p.first == 42);
        assert(p.second.value == -42);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
index fcaa44849..e147d7558 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
@@ -46,7 +46,7 @@ void test_sfinae() {
     static_assert(test_convertible<P2,   T2,   T1Arg>() == CanConvert, "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<float, short*> P;
@@ -94,4 +94,6 @@ int main()
         static_assert(p.second == 10, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
index 4759303d6..880179723 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
@@ -24,7 +24,7 @@ public:
     bool operator==(const A& a) const {return data_ == a.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<float, short*> P;
@@ -38,4 +38,6 @@ int main()
         assert(p.first == A(1));
         assert(p.second == 2);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
index c9c733d8c..ce1e86c1a 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -53,7 +53,7 @@ struct ImplicitT {
   int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, int> P1;
@@ -177,4 +177,6 @@ int main()
         static_assert(p2.second.value == 101, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
index 8a3fca758..9f6498806 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
@@ -15,7 +15,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -25,4 +25,6 @@ int main()
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
index bee96000e..81a32901a 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -35,4 +35,6 @@ int main()
         static_assert(p2.second == 4, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
index b3a248c88..70557aa92 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
@@ -139,7 +139,7 @@ void test_illformed_default()
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         // Check that pair<T, U> can still be used even if
@@ -160,4 +160,6 @@ int main()
         test_is_default_constructible<int>();
         test_is_default_constructible<DefaultSFINAES<int>>();
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
index 9a07814b1..dc1f37b66 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_macros.h"
 #include "archetypes.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<float, short*> P;
@@ -51,4 +51,6 @@ int main()
         static_assert(!std::is_default_constructible<P2>::value, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
index df9cbc757..268ec4294 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
@@ -26,10 +26,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   static_assert((std::is_trivially_destructible<
       std::pair<int, float> >::value), "");
   static_assert((!std::is_trivially_destructible<
       std::pair<int, std::string> >::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
index 4b7529388..ca5a72884 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
@@ -39,7 +39,7 @@
 // (6)  explicit pair(pair<U1, U2> const&) -> pair<U1, U2>
 // (7)  pair(pair<U1, U2> &&) -> pair<U1, U2>
 // (8)  explicit pair(pair<U1, U2> &&) -> pair<U1, U2>
-int main()
+int main(int, char**)
 {
   using E = ExplicitTestTypes::TestType;
   static_assert(!std::is_convertible<E const&, E>::value, "");
@@ -76,4 +76,6 @@ int main()
     std::pair p1(std::move(p));
     ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, E>);
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
index 92a0aa42b..53d81ac7a 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
@@ -25,7 +25,7 @@ struct Dummy {
   Dummy(Dummy &&) = default;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -40,4 +40,6 @@ int main()
         static_assert(!std::is_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp b/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
index 325499eaf..88d0f9649 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
@@ -27,7 +27,7 @@ struct ImplicitT {
   int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using P = std::pair<int, int>;
@@ -53,4 +53,6 @@ int main()
         constexpr P U_V = {42, 101}; // expected-error {{must be initialized by a constant expression}}
         constexpr P pair_U_V = other; // expected-error {{must be initialized by a constant expression}}
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
index 3c93eeb3d..26b02f383 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
@@ -21,7 +21,7 @@
 #include <utility>
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, int*> P1;
@@ -32,4 +32,6 @@ int main()
         assert(p3.first == P1(3, nullptr));
         assert(p3.second == P2(nullptr, 4));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
index b38ca2a3b..0e3d9a1cb 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -63,7 +63,7 @@ struct ImplicitT {
   int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<Derived>, int> P1;
@@ -173,4 +173,6 @@ int main()
         static_assert(p2.second.value == 43, "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
index 48ea5fac6..db174e829 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
@@ -120,7 +120,9 @@ void test_assignment_operator_exists() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_constructors_exist();
   test_assignment_operator_exists();
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
index 58a5c2932..faaae1bc2 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
@@ -24,7 +24,7 @@ struct S {
     bool operator==(int x) const { return i == x; }
     };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -46,4 +46,6 @@ int main()
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
index e4b444a34..6841f2865 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
@@ -26,7 +26,7 @@ struct Dummy {
   Dummy(Dummy &&) = default;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<int, short> P;
     {
@@ -52,4 +52,6 @@ int main()
 #endif
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
index abda1d8c3..25108de5b 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
@@ -17,9 +17,11 @@
 #include <utility>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<float, short*> P;
     static_assert((std::is_same<P::first_type, float>::value), "");
     static_assert((std::is_same<P::second_type, short*>::value), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp b/test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp
index 3b994dfd4..12d6ab019 100644
--- a/test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -94,4 +94,6 @@ int main()
         static_assert( (p1 >= p2), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp b/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
index 3586243f8..dff26e57f 100644
--- a/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -49,4 +49,6 @@ int main()
     }
 #endif
 
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp b/test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp
index 62fa94247..874327672 100644
--- a/test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -28,4 +28,6 @@ int main()
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/synopsis.pass.cpp b/test/std/utilities/utility/synopsis.pass.cpp
index 90c5e3218..5a703e1b2 100644
--- a/test/std/utilities/utility/synopsis.pass.cpp
+++ b/test/std/utilities/utility/synopsis.pass.cpp
@@ -13,9 +13,11 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     std::initializer_list<int> x;
     (void)x;
+
+  return 0;
 }
 
diff --git a/test/std/utilities/utility/utility.inplace/inplace.pass.cpp b/test/std/utilities/utility/utility.inplace/inplace.pass.cpp
index 53fa3cf66..155b2c0eb 100644
--- a/test/std/utilities/utility/utility.inplace/inplace.pass.cpp
+++ b/test/std/utilities/utility/utility.inplace/inplace.pass.cpp
@@ -42,7 +42,7 @@ constexpr bool check_tag(Up) {
         && std::is_same<Tp, Up>::value;
 }
 
-int main() {
+int main(int, char**) {
     // test in_place_t
     {
         using T = std::in_place_t;
@@ -70,4 +70,6 @@ int main() {
         static_assert(check_tag<T2>(std::in_place_index<1>));
         static_assert(check_tag<T3>(std::in_place_index<static_cast<size_t>(-1)>));
     }
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/utility.swap/swap.pass.cpp b/test/std/utilities/utility/utility.swap/swap.pass.cpp
index 9dda5a42c..f52af4cb8 100644
--- a/test/std/utilities/utility/utility.swap/swap.pass.cpp
+++ b/test/std/utilities/utility/utility.swap/swap.pass.cpp
@@ -62,7 +62,7 @@ constexpr bool can_swap() {
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -99,4 +99,6 @@ int main()
         static_assert(noexcept(std::swap(nm, nm)), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/utility/utility.swap/swap_array.pass.cpp b/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
index 202e8d33f..015e85a01 100644
--- a/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
+++ b/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
@@ -54,7 +54,7 @@ constexpr bool can_swap() {
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
         int i[3] = {1, 2, 3};
@@ -97,4 +97,6 @@ int main()
         static_assert(noexcept(std::swap(ma, ma)), "");
     }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
index 1585e1745..cb66771fc 100644
--- a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
+++ b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
@@ -35,11 +35,13 @@ public:
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_base_of<std::exception, std::bad_variant_access>::value,
                 "");
   static_assert(noexcept(std::bad_variant_access{}), "must be noexcept");
   static_assert(noexcept(std::bad_variant_access{}.what()), "must be noexcept");
   std::bad_variant_access ex;
   assert(ex.what());
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp b/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
index 0c118a0f5..8002e5576 100644
--- a/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
+++ b/test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
@@ -7,4 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
diff --git a/test/std/utilities/variant/variant.get/get_if_index.pass.cpp b/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
index 505a8cb8e..5210c5f9d 100644
--- a/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_if_index.pass.cpp
@@ -125,7 +125,9 @@ void test_get_if() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_get_if();
   test_get_if();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.get/get_if_type.pass.cpp b/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
index 3cb0fc705..e7c9671f9 100644
--- a/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_if_type.pass.cpp
@@ -123,7 +123,9 @@ void test_get_if() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_get_if();
   test_get_if();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.get/get_index.pass.cpp b/test/std/utilities/variant/variant.get/get_index.pass.cpp
index a5a629adb..5519c4263 100644
--- a/test/std/utilities/variant/variant.get/get_index.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_index.pass.cpp
@@ -285,10 +285,12 @@ void test_throws_for_all_value_categories() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_lvalue_get();
   test_lvalue_get();
   test_rvalue_get();
   test_const_rvalue_get();
   test_throws_for_all_value_categories();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.get/get_type.pass.cpp b/test/std/utilities/variant/variant.get/get_type.pass.cpp
index b4cae1027..76bbbb026 100644
--- a/test/std/utilities/variant/variant.get/get_type.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_type.pass.cpp
@@ -285,10 +285,12 @@ void test_throws_for_all_value_categories() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_lvalue_get();
   test_lvalue_get();
   test_rvalue_get();
   test_const_rvalue_get();
   test_throws_for_all_value_categories();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp b/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
index 3e9cfbe9c..b37462069 100644
--- a/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
+++ b/test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include <variant>
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int>;
     constexpr V v;
@@ -34,4 +34,6 @@ int main() {
     const V v;
     ASSERT_NOEXCEPT(std::holds_alternative<int>(v));
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp b/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
index 404f3e7e5..7e9ffbfa0 100644
--- a/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
+++ b/test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.hash/hash.pass.cpp b/test/std/utilities/variant/variant.hash/hash.pass.cpp
index 5acf168ad..edda8d21a 100644
--- a/test/std/utilities/variant/variant.hash/hash.pass.cpp
+++ b/test/std/utilities/variant/variant.hash/hash.pass.cpp
@@ -150,9 +150,11 @@ void test_hash_variant_enabled() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_hash_variant();
   test_hash_variant_duplicate_elements();
   test_hash_monostate();
   test_hash_variant_enabled();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
index f7db0d86b..48d5e14e2 100644
--- a/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
+++ b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
@@ -25,7 +25,9 @@
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
     using V = std::variant<int, void *, const void *, long double>;
     std::variant_alternative<4, V>::type foo;  // expected-error@variant:* {{Index out of bounds in std::variant_alternative<>}}
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp b/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
index 841f65cb1..7db07b6b0 100644
--- a/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
+++ b/test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
@@ -55,7 +55,7 @@ template <class V, size_t I, class E> void test() {
                 "");
 }
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, void *, const void *, long double>;
     test<V, 0, int>();
@@ -73,4 +73,6 @@ int main() {
     test<V, 4, long double>();
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp b/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
index f7e200b24..fb027fb63 100644
--- a/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
+++ b/test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
@@ -36,8 +36,10 @@ template <class V, size_t E> void test() {
                 "");
 };
 
-int main() {
+int main(int, char**) {
   test<std::variant<>, 0>();
   test<std::variant<void *>, 1>();
   test<std::variant<long, long, void *, double>, 4>();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp b/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
index 2df4b2bac..255f6d034 100644
--- a/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
+++ b/test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
   using M = std::monostate;
   constexpr M m1{};
   constexpr M m2{};
@@ -51,4 +51,6 @@ int main() {
     static_assert((m1 != m2) == false, "");
     ASSERT_NOEXCEPT(m1 != m2);
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.monostate/monostate.pass.cpp b/test/std/utilities/variant/variant.monostate/monostate.pass.cpp
index 1d7bcaca4..1ba75a779 100644
--- a/test/std/utilities/variant/variant.monostate/monostate.pass.cpp
+++ b/test/std/utilities/variant/variant.monostate/monostate.pass.cpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
   using M = std::monostate;
   static_assert(std::is_trivially_default_constructible<M>::value, "");
   static_assert(std::is_trivially_copy_constructible<M>::value, "");
@@ -24,4 +24,6 @@ int main() {
   static_assert(std::is_trivially_destructible<M>::value, "");
   constexpr M m{};
   ((void)m);
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.relops/relops.pass.cpp b/test/std/utilities/variant/variant.relops/relops.pass.cpp
index 1950b5a38..ed32215ff 100644
--- a/test/std/utilities/variant/variant.relops/relops.pass.cpp
+++ b/test/std/utilities/variant/variant.relops/relops.pass.cpp
@@ -269,7 +269,9 @@ void test_relational() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_equality();
   test_relational();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp b/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
index d03a6b5d5..e46893465 100644
--- a/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
+++ b/test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
@@ -72,7 +72,7 @@ inline constexpr MyBoolExplicit operator>=(const ComparesToMyBoolExplicit& LHS,
 }
 
 
-int main() {
+int main(int, char**) {
   using V = std::variant<int, ComparesToMyBoolExplicit>;
   V v1(42);
   V v2(101);
@@ -84,4 +84,6 @@ int main() {
   (void)(v1 <= v2); // expected-note {{here}}
   (void)(v1 > v2); // expected-note {{here}}
   (void)(v1 >= v2); // expected-note {{here}}
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp b/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
index aadda7eac..310b6980c 100644
--- a/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
+++ b/test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
@@ -15,6 +15,8 @@
 
 #include <variant>
 
-int main() {
+int main(int, char**) {
   static_assert(std::variant_npos == static_cast<std::size_t>(-1), "");
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
index 67deb3f2c..6a4bb0486 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -254,10 +254,12 @@ void test_T_assignment_performs_assignment() {
 #endif // TEST_HAS_NO_EXCEPTIONS
 }
 
-int main() {
+int main(int, char**) {
   test_T_assignment_basic();
   test_T_assignment_performs_construction();
   test_T_assignment_performs_assignment();
   test_T_assignment_noexcept();
   test_T_assignment_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index 6a59989dd..c36375cf2 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -590,7 +590,7 @@ void test_constexpr_copy_assignment() {
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_copy_assignment_empty_empty();
   test_copy_assignment_non_empty_empty();
   test_copy_assignment_empty_non_empty();
@@ -599,4 +599,6 @@ int main() {
   test_copy_assignment_sfinae();
   test_copy_assignment_not_noexcept();
   test_constexpr_copy_assignment();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index 833883d29..c213af4b2 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -506,7 +506,7 @@ void test_constexpr_move_assignment() {
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_move_assignment_empty_empty();
   test_move_assignment_non_empty_empty();
   test_move_assignment_empty_non_empty();
@@ -515,4 +515,6 @@ int main() {
   test_move_assignment_sfinae();
   test_move_assignment_noexcept();
   test_constexpr_move_assignment();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
index 7357b9b56..4ebfe052d 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -126,8 +126,10 @@ void test_T_ctor_basic() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_T_ctor_basic();
   test_T_ctor_noexcept();
   test_T_ctor_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index b6471052f..00c94ee33 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -260,7 +260,7 @@ void test_constexpr_copy_ctor() {
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_copy_ctor_basic();
   test_copy_ctor_valueless_by_exception();
   test_copy_ctor_sfinae();
@@ -274,4 +274,6 @@ int main() {
   (void) v2;
 }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
index ec6eb289b..1766ee1db 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
@@ -122,9 +122,11 @@ void test_default_ctor_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_default_ctor_basic();
   test_default_ctor_sfinae();
   test_default_ctor_noexcept();
   test_default_ctor_throws();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
index a268adcea..cb7d68a65 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
@@ -104,7 +104,9 @@ void test_ctor_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
index 9c7e3faf8..4b78bf569 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
@@ -110,7 +110,9 @@ void test_ctor_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
index 05b2a29ce..ab8fe0688 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
@@ -114,7 +114,9 @@ void test_ctor_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
index c3f3e58d3..4061cfb25 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
@@ -111,7 +111,9 @@ void test_ctor_basic() {
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index ecb4a7207..f146e16d3 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -331,10 +331,12 @@ void test_constexpr_move_ctor() {
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_move_ctor_basic();
   test_move_ctor_valueless_by_exception();
   test_move_noexcept();
   test_move_ctor_sfinae();
   test_constexpr_move_ctor();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp b/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
index 8ced5321b..b26ab0c29 100644
--- a/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
@@ -44,7 +44,7 @@ struct TDtor {
 static_assert(!std::is_trivially_copy_constructible<TDtor>::value, "");
 static_assert(std::is_trivially_destructible<TDtor>::value, "");
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, long, TDtor>;
     static_assert(std::is_trivially_destructible<V>::value, "");
@@ -71,4 +71,6 @@ int main() {
     assert(NonTDtor::count == 0);
     assert(NonTDtor1::count == 1);
   }
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
index ea84ac940..b688c8e7a 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -159,7 +159,9 @@ void test_basic() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
index 13e3c927c..9d96a1dc2 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -92,7 +92,9 @@ void test_basic() {
   assert(&ref3 == &std::get<1>(v));
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
index 7c9034f10..0719f5e7b 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -159,7 +159,9 @@ void test_basic() {
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
index 85cd25d04..49839eda4 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -92,7 +92,9 @@ void test_basic() {
   assert(&ref3 == &std::get<InitList>(v));
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp b/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
index 0afa10138..6d463ad27 100644
--- a/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
@@ -25,7 +25,7 @@
 #include "variant_test_helpers.hpp"
 
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, long>;
     constexpr V v;
@@ -57,4 +57,6 @@ int main() {
     assert(v.index() == std::variant_npos);
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp b/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
index 147f380a1..2cb730cb0 100644
--- a/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
@@ -25,7 +25,7 @@
 #include "variant_test_helpers.hpp"
 
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, long>;
     constexpr V v;
@@ -50,4 +50,6 @@ int main() {
     assert(v.valueless_by_exception());
   }
 #endif
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
index e05cd13e6..4e273f52e 100644
--- a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -589,10 +589,12 @@ void test_swap_noexcept() {
 template class std::variant<int, NotSwappable>;
 #endif
 
-int main() {
+int main(int, char**) {
   test_swap_valueless_by_exception();
   test_swap_same_alternative();
   test_swap_different_alternatives();
   test_swap_sfinae();
   test_swap_noexcept();
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant_array.fail.cpp b/test/std/utilities/variant/variant.variant/variant_array.fail.cpp
index a9caeb8b2..ce79e9c42 100644
--- a/test/std/utilities/variant/variant.variant/variant_array.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_array.fail.cpp
@@ -23,10 +23,12 @@
 #include "variant_test_helpers.hpp"
 #include "test_convertible.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, int[]> v; // expected-note {{requested here}}
     std::variant<int, int[42]> v2; // expected-note {{requested here}}
     std::variant<int, int[][42]> v3; // expected-note {{requested here}}
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp b/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
index 85a10eff9..3b93cb0ab 100644
--- a/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
@@ -18,8 +18,10 @@
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 1 {{static_assert failed}}
     std::variant<> v; // expected-note {{requested here}}
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp b/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
index e659f4760..7c2c46690 100644
--- a/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
@@ -18,10 +18,12 @@
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, int&> v; // expected-note {{requested here}}
     std::variant<int, const int &> v2; // expected-note {{requested here}}
     std::variant<int, int&&> v3; // expected-note {{requested here}}
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.variant/variant_void.fail.cpp b/test/std/utilities/variant/variant.variant/variant_void.fail.cpp
index ce0675d73..27e9c399f 100644
--- a/test/std/utilities/variant/variant.variant/variant_void.fail.cpp
+++ b/test/std/utilities/variant/variant.variant/variant_void.fail.cpp
@@ -23,10 +23,12 @@
 #include "variant_test_helpers.hpp"
 #include "test_convertible.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, void> v; // expected-note {{requested here}}
     std::variant<int, const void> v2; // expected-note {{requested here}}
     std::variant<const volatile void, int> v3; // expected-note {{requested here}}
+
+  return 0;
 }
diff --git a/test/std/utilities/variant/variant.visit/visit.pass.cpp b/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 198f310e9..15a1de984 100644
--- a/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -310,10 +310,12 @@ void test_caller_accepts_nonconst() {
   std::visit(Visitor{}, v);
 }
 
-int main() {
+int main(int, char**) {
   test_call_operator_forwarding();
   test_argument_forwarding();
   test_constexpr();
   test_exceptions();
   test_caller_accepts_nonconst();
+
+  return 0;
 }
diff --git a/test/support/nothing_to_do.pass.cpp b/test/support/nothing_to_do.pass.cpp
index 1b2313324..f54d71c86 100644
--- a/test/support/nothing_to_do.pass.cpp
+++ b/test/support/nothing_to_do.pass.cpp
@@ -7,7 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
diff --git a/test/support/test.support/test_convertible_header.pass.cpp b/test/support/test.support/test_convertible_header.pass.cpp
index 0158dfe62..f2923d50c 100644
--- a/test/support/test.support/test_convertible_header.pass.cpp
+++ b/test/support/test.support/test_convertible_header.pass.cpp
@@ -62,6 +62,8 @@ struct ExplicitArgs {
 };
 static_assert(!test_convertible<ExplicitArgs, int, int, int>(), "Must not be convertible");
 
-int main() {
+int main(int, char**) {
     // Nothing to do
+
+  return 0;
 }
diff --git a/test/support/test.support/test_demangle.pass.cpp b/test/support/test.support/test_demangle.pass.cpp
index 5c62ecbb1..2f1b16be9 100644
--- a/test/support/test.support/test_demangle.pass.cpp
+++ b/test/support/test.support/test_demangle.pass.cpp
@@ -14,7 +14,7 @@ struct MyType {};
 
 template <class T, class U> struct ArgumentListID {};
 
-int main() {
+int main(int, char**) {
   struct {
     const char* raw;
     const char* expect;
@@ -34,4 +34,6 @@ int main() {
     assert(demangle(raw) == expect);
 #endif
   }
+
+  return 0;
 }
diff --git a/test/support/test.support/test_macros_header_exceptions.fail.cpp b/test/support/test.support/test_macros_header_exceptions.fail.cpp
index 66a01c967..b120aabc0 100644
--- a/test/support/test.support/test_macros_header_exceptions.fail.cpp
+++ b/test/support/test.support/test_macros_header_exceptions.fail.cpp
@@ -12,7 +12,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_HAS_NO_EXCEPTIONS)
     try { ((void)0); } catch (...) {} // expected-error {{exceptions disabled}}
 #else
@@ -20,4 +20,6 @@ int main() {
 #error exceptions enabled
 // expected-error@-1 {{exceptions enabled}}
 #endif
+
+  return 0;
 }
diff --git a/test/support/test.support/test_macros_header_exceptions.pass.cpp b/test/support/test.support/test_macros_header_exceptions.pass.cpp
index 274cad82e..ccdf257dc 100644
--- a/test/support/test.support/test_macros_header_exceptions.pass.cpp
+++ b/test/support/test.support/test_macros_header_exceptions.pass.cpp
@@ -18,6 +18,8 @@
 #error macro defined unexpectedly
 #endif
 
-int main() {
+int main(int, char**) {
     try { ((void)0); } catch (...) {}
+
+  return 0;
 }
diff --git a/test/support/test.support/test_macros_header_rtti.fail.cpp b/test/support/test.support/test_macros_header_rtti.fail.cpp
index 4096ce43f..b2f3177af 100644
--- a/test/support/test.support/test_macros_header_rtti.fail.cpp
+++ b/test/support/test.support/test_macros_header_rtti.fail.cpp
@@ -15,7 +15,7 @@
 struct A { virtual ~A() {} };
 struct B : A {};
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_HAS_NO_RTTI)
     A* ptr = new B;
     (void)dynamic_cast<B*>(ptr); // expected-error{{cannot use dynamic_cast}}
@@ -25,4 +25,6 @@ int main() {
 #error RTTI enabled
 // expected-error@-1{{RTTI enabled}}
 #endif
+
+  return 0;
 }
diff --git a/test/support/test.support/test_macros_header_rtti.pass.cpp b/test/support/test.support/test_macros_header_rtti.pass.cpp
index 946157993..e38545f9b 100644
--- a/test/support/test.support/test_macros_header_rtti.pass.cpp
+++ b/test/support/test.support/test_macros_header_rtti.pass.cpp
@@ -21,8 +21,10 @@
 struct A { virtual ~A() {} };
 struct B : A {};
 
-int main() {
+int main(int, char**) {
     A* ptr = new B;
     (void)dynamic_cast<B*>(ptr);
     delete ptr;
+
+  return 0;
 }
diff --git a/test/support/test.support/test_poisoned_hash_helper.pass.cpp b/test/support/test.support/test_poisoned_hash_helper.pass.cpp
index f94f96368..692854b3d 100644
--- a/test/support/test.support/test_poisoned_hash_helper.pass.cpp
+++ b/test/support/test.support/test_poisoned_hash_helper.pass.cpp
@@ -24,6 +24,8 @@ template <class T> struct has_complete_hash {
   enum { value = is_complete<std::hash<T> >() };
 };
 
-int main() {
+int main(int, char**) {
   static_assert(LibraryHashTypes::assertTrait<has_complete_hash, false>(), "");
+
+  return 0;
 }
diff --git a/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp b/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
index 40e50c14e..1b2fd1462 100644
--- a/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
+++ b/test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
@@ -25,10 +25,12 @@ struct S {
   S& operator=(S&&) = delete;
 };
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE)
   static_assert(!std::is_trivially_copyable<S>::value, "");
 #else
   static_assert(std::is_trivially_copyable<S>::value, "");
 #endif
+
+  return 0;
 }
diff --git a/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp b/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
index 27f1fb640..688a0f798 100644
--- a/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
+++ b/test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
@@ -31,10 +31,12 @@ template<class T = int>
 auto test(int) -> decltype(PushFront(std::declval<T>()), std::true_type{});
 auto test(long) -> std::false_type;
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK)
     static_assert(!decltype(test(0))::value, "");
 #else
     static_assert(decltype(test(0))::value, "");
 #endif
+
+  return 0;
 }
diff --git a/utils/generate_feature_test_macro_components.py b/utils/generate_feature_test_macro_components.py
index 2bd80a858..d923208a1 100755
--- a/utils/generate_feature_test_macro_components.py
+++ b/utils/generate_feature_test_macro_components.py
@@ -865,7 +865,7 @@ def produce_tests():
 
 #endif // TEST_STD_VER > 17
 
-int main() {{}}
+int main(int, char**) { return 0; }
 """.format(script_name=script_name,
            header=h,
            test_tags=test_tags,
-- 
GitLab


From 6b1420d0f2e642e71e886ecaa88eb4c3bbb40b56 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Tue, 5 Feb 2019 04:44:03 +0000
Subject: [PATCH 108/137] [CMake] Update lit test configuration

There are several changes:
- Don't stringify Pythonized bools (that's why we're Pythonizing them)
- Support specifying target and sysroot via CMake variables
- Use consistent spelling for --target, --sysroot, --gcc-toolchain

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353137 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/lit.site.cfg.in        | 28 ++++++++++++++--------------
 utils/libcxx/test/config.py |  8 ++++----
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
index cb7b62c9a..019cca8a2 100644
--- a/test/lit.site.cfg.in
+++ b/test/lit.site.cfg.in
@@ -4,12 +4,12 @@ config.project_obj_root         = "@CMAKE_BINARY_DIR@"
 config.libcxx_src_root          = "@LIBCXX_SOURCE_DIR@"
 config.libcxx_obj_root          = "@LIBCXX_BINARY_DIR@"
 config.cxx_library_root         = "@LIBCXX_LIBRARY_DIR@"
-config.enable_exceptions        = "@LIBCXX_ENABLE_EXCEPTIONS@"
-config.enable_experimental      = "@LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY@"
-config.enable_filesystem        = "@LIBCXX_ENABLE_FILESYSTEM@"
-config.enable_rtti              = "@LIBCXX_ENABLE_RTTI@"
-config.enable_shared            = "@LIBCXX_ENABLE_SHARED@"
-config.enable_32bit             = "@LIBCXX_BUILD_32_BITS@"
+config.enable_exceptions        = @LIBCXX_ENABLE_EXCEPTIONS@
+config.enable_experimental      = @LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY@
+config.enable_filesystem        = @LIBCXX_ENABLE_FILESYSTEM@
+config.enable_rtti              = @LIBCXX_ENABLE_RTTI@
+config.enable_shared            = @LIBCXX_ENABLE_SHARED@
+config.enable_32bit             = @LIBCXX_BUILD_32_BITS@
 config.cxx_abi                  = "@LIBCXX_CXX_ABI_LIBNAME@"
 config.use_sanitizer            = "@LLVM_USE_SANITIZER@"
 config.sanitizer_library        = "@LIBCXX_SANITIZER_LIBRARY@"
@@ -20,19 +20,19 @@ config.target_triple            = "@TARGET_TRIPLE@"
 config.use_target               = bool("@LIBCXX_TARGET_TRIPLE@")
 config.sysroot                  = "@LIBCXX_SYSROOT@"
 config.gcc_toolchain            = "@LIBCXX_GCC_TOOLCHAIN@"
-config.generate_coverage        = "@LIBCXX_GENERATE_COVERAGE@"
+config.generate_coverage        = @LIBCXX_GENERATE_COVERAGE@
 config.target_info              = "@LIBCXX_TARGET_INFO@"
 config.test_linker_flags        = "@LIBCXX_TEST_LINKER_FLAGS@"
 config.test_compiler_flags      = "@LIBCXX_TEST_COMPILER_FLAGS@"
 
 config.executor                 = "@LIBCXX_EXECUTOR@"
-config.llvm_unwinder            = "@LIBCXXABI_USE_LLVM_UNWINDER@"
-config.compiler_rt              = "@LIBCXX_USE_COMPILER_RT@"
-config.has_libatomic            = "@LIBCXX_HAS_ATOMIC_LIB@"
-config.use_libatomic            = "@LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB@"
-config.debug_build              = "@LIBCXX_DEBUG_BUILD@"
-config.libcxxabi_shared         = "@LIBCXXABI_ENABLE_SHARED@"
-config.cxx_ext_threads          = "@LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY@"
+config.llvm_unwinder            = @LIBCXXABI_USE_LLVM_UNWINDER@
+config.compiler_rt              = @LIBCXX_USE_COMPILER_RT@
+config.has_libatomic            = @LIBCXX_HAS_ATOMIC_LIB@
+config.use_libatomic            = @LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB@
+config.debug_build              = @LIBCXX_DEBUG_BUILD@
+config.libcxxabi_shared         = @LIBCXXABI_ENABLE_SHARED@
+config.cxx_ext_threads          = @LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY@
 
 # Let the main config do the real work.
 config.loaded_site_config = True
diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index aba1ada90..a16bbdef5 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -547,10 +547,10 @@ class Configuration(object):
         self.cxx.flags += ['-v']
         sysroot = self.get_lit_conf('sysroot')
         if sysroot:
-            self.cxx.flags += ['--sysroot', sysroot]
+            self.cxx.flags += ['--sysroot=' + sysroot]
         gcc_toolchain = self.get_lit_conf('gcc_toolchain')
         if gcc_toolchain:
-            self.cxx.flags += ['-gcc-toolchain', gcc_toolchain]
+            self.cxx.flags += ['--gcc-toolchain=' + gcc_toolchain]
         # NOTE: the _DEBUG definition must preceed the triple check because for
         # the Windows build of libc++, the forced inclusion of a header requires
         # that _DEBUG is defined.  Incorrect ordering will result in -target
@@ -559,8 +559,8 @@ class Configuration(object):
             self.cxx.compile_flags += ['-D_DEBUG']
         if self.use_target:
             if not self.cxx.addFlagIfSupported(
-                    ['-target', self.config.target_triple]):
-                self.lit_config.warning('use_target is true but -target is '\
+                    ['--target=' + self.config.target_triple]):
+                self.lit_config.warning('use_target is true but --target is '\
                         'not supported by the compiler')
         if self.use_deployment:
             arch, name, version = self.config.deployment
-- 
GitLab


From c64eb1f8cf27531aaa60336eaefdc8fa0de28f83 Mon Sep 17 00:00:00 2001
From: JF Bastien <jfbastien@apple.com>
Date: Tue, 5 Feb 2019 05:34:12 +0000
Subject: [PATCH 109/137] Fix double curlies

Pointed out by Arthur in D57624.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353140 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/generate_feature_test_macro_components.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/generate_feature_test_macro_components.py b/utils/generate_feature_test_macro_components.py
index d923208a1..c11846ec6 100755
--- a/utils/generate_feature_test_macro_components.py
+++ b/utils/generate_feature_test_macro_components.py
@@ -865,7 +865,7 @@ def produce_tests():
 
 #endif // TEST_STD_VER > 17
 
-int main(int, char**) { return 0; }
+int main(int, char**) {{ return 0; }}
 """.format(script_name=script_name,
            header=h,
            test_tags=test_tags,
-- 
GitLab


From 72ea6f36d1ca294c85ad715ade6a458690c9a55f Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 5 Feb 2019 15:46:52 +0000
Subject: [PATCH 110/137] [NFC][libc++] Reindent function

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353180 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/filesystem | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/include/filesystem b/include/filesystem
index 7fb25116b..7a151d988 100644
--- a/include/filesystem
+++ b/include/filesystem
@@ -1364,13 +1364,11 @@ private:
 template <class... _Args>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    void
-    __throw_filesystem_error(_Args&&... __args) {
+void __throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(std::forward<_Args>(__args)...);
 }
 #else
-    void
-    __throw_filesystem_error(_Args&&...) {
+void __throw_filesystem_error(_Args&&...) {
   _VSTD::abort();
 }
 #endif
-- 
GitLab


From 815d7557064f0cb06ae1a8a78f95486db55758a3 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 5 Feb 2019 16:42:37 +0000
Subject: [PATCH 111/137] [libc++] Control whether exceptions are enabled in
 the macOS trunk testing script

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353185 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/ci/macos-trunk.sh | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/utils/ci/macos-trunk.sh b/utils/ci/macos-trunk.sh
index b365cc6d8..b64633387 100755
--- a/utils/ci/macos-trunk.sh
+++ b/utils/ci/macos-trunk.sh
@@ -8,13 +8,14 @@ $(basename ${0}) [-h|--help] --libcxx-root <LIBCXX-ROOT> --libcxxabi-root <LIBCX
 
 This script is used to continually test libc++ and libc++abi trunk on MacOS.
 
-  --libcxx-root     Full path to the root of the libc++ repository to test.
-  --libcxxabi-root  Full path to the root of the libc++abi repository to test.
-  --std             Version of the C++ Standard to run the tests under (c++03, c++11, etc..).
-  --arch            Architecture to build the tests for (32, 64).
-  [--lit-args]      Additional arguments to pass to lit (optional). If there are multiple arguments, quote them to pass them as a single argument to this script.
-  [--no-cleanup]    Do not cleanup the temporary directory that was used for testing at the end. This can be useful to debug failures. Make sure to clean up manually after.
-  [-h, --help]      Print this help.
+  --libcxx-root       Full path to the root of the libc++ repository to test.
+  --libcxxabi-root    Full path to the root of the libc++abi repository to test.
+  --std               Version of the C++ Standard to run the tests under (c++03, c++11, etc..).
+  --arch              Architecture to build the tests for (32, 64).
+  --libcxx-exceptions Whether to enable exceptions when building libc++ and running the libc++ tests. libc++abi is always built with support for exceptions because other libraries in the runtime depend on it (like libobjc). This must be ON or OFF.
+  [--lit-args]        Additional arguments to pass to lit (optional). If there are multiple arguments, quote them to pass them as a single argument to this script.
+  [--no-cleanup]      Do not cleanup the temporary directory that was used for testing at the end. This can be useful to debug failures. Make sure to clean up manually after.
+  [-h, --help]        Print this help.
 EOM
 }
 
@@ -46,6 +47,10 @@ while [[ $# -gt 0 ]]; do
     ARCH="${2}"
     shift; shift
     ;;
+    --libcxx-exceptions)
+    LIBCXX_EXCEPTIONS="${2}"
+    shift; shift
+    ;;
     --lit-args)
     ADDITIONAL_LIT_ARGS="${2}"
     shift; shift
@@ -70,6 +75,7 @@ if [[ -z ${LIBCXX_ROOT+x} ]]; then echo "--libcxx-root is a required parameter";
 if [[ -z ${LIBCXXABI_ROOT+x} ]]; then echo "--libcxxabi-root is a required parameter"; usage; exit 1; fi
 if [[ -z ${STD+x} ]]; then echo "--std is a required parameter"; usage; exit 1; fi
 if [[ -z ${ARCH+x} ]]; then echo "--arch is a required parameter"; usage; exit 1; fi
+if [[ "${LIBCXX_EXCEPTIONS}" != "ON" && "${LIBCXX_EXCEPTIONS}" != "OFF" ]]; then echo "--libcxx-exceptions is a required parameter and must be either ON or OFF"; usage; exit 1; fi
 if [[ -z ${ADDITIONAL_LIT_ARGS+x} ]]; then ADDITIONAL_LIT_ARGS=""; fi
 
 
@@ -117,6 +123,7 @@ mkdir -p "${LIBCXX_BUILD_DIR}"
   xcrun cmake "${LIBCXX_ROOT}" -GNinja \
     -DLLVM_PATH="${LLVM_ROOT}" \
     -DCMAKE_INSTALL_PREFIX="${LIBCXX_INSTALL_DIR}" \
+    -DLIBCXX_ENABLE_EXCEPTIONS="${LIBCXX_EXCEPTIONS}" \
     -DLLVM_LIT_ARGS="${LIT_FLAGS}" \
     -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" # Build a universal dylib
 )
@@ -130,6 +137,7 @@ mkdir -p "${LIBCXXABI_BUILD_DIR}"
     -DLIBCXXABI_LIBCXX_PATH="${LIBCXX_ROOT}" \
     -DLLVM_PATH="${LLVM_ROOT}" \
     -DCMAKE_INSTALL_PREFIX="${LIBCXXABI_INSTALL_DIR}" \
+    -DLIBCXXABI_ENABLE_EXCEPTIONS=ON \
     -DLLVM_LIT_ARGS="${LIT_FLAGS}" \
     -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" # Build a universal dylib
 )
-- 
GitLab


From 60c45f5f7c7081af3f5176bf448eca7b6793d953 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 5 Feb 2019 19:22:38 +0000
Subject: [PATCH 112/137] [libcxx] Start defining lit features for tests
 depending on availability

This patch removes some vendor-specific availability XFAILs from the
test suite. In the future, when a new feature is introduced in the
dylib, an availability macro should be created and a matching lit
feature should be created. That way, the test suite can XFAIL whenever
the implementation lacks the necessary feature instead of being
cluttered by vendor-specific annotations.

Right now, those vendor-specific annotations are still somewhat cluttering
the test suite by being in `config.py`, but at least they are localized.
In the future, we could design a way to define those less intrusively or
even automatically based on the availability macros that already exist
in <__config>.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353201 91177308-0d34-0410-b5e6-96231b3b80d8
---
 docs/DesignDocs/AvailabilityMarkup.rst               |  6 ++++++
 .../utilities/any/any.class/any.assign/copy.pass.cpp |  8 +-------
 .../utilities/any/any.class/any.assign/move.pass.cpp |  8 +-------
 .../any/any.class/any.assign/value.pass.cpp          |  8 +-------
 .../utilities/any/any.class/any.cons/copy.pass.cpp   |  8 +-------
 .../any/any.class/any.cons/in_place_type.pass.cpp    |  8 +-------
 .../utilities/any/any.class/any.cons/move.pass.cpp   |  8 +-------
 .../utilities/any/any.class/any.cons/value.pass.cpp  |  8 +-------
 .../any/any.class/any.modifiers/emplace.pass.cpp     |  8 +-------
 .../any/any.class/any.modifiers/reset.pass.cpp       |  8 +-------
 .../any/any.class/any.modifiers/swap.pass.cpp        |  8 +-------
 .../any.cast/any_cast_pointer.pass.cpp               |  8 +-------
 .../any.cast/any_cast_reference.pass.cpp             |  8 +-------
 .../utilities/any/any.nonmembers/make_any.pass.cpp   |  8 +-------
 test/std/utilities/any/any.nonmembers/swap.pass.cpp  |  8 +-------
 .../optional.bad_optional_access/default.pass.cpp    |  8 +-------
 .../optional.bad_optional_access/derive.pass.cpp     |  9 +--------
 .../optional.object/optional.object.ctor/U.pass.cpp  |  8 +-------
 .../optional.object.ctor/const_T.pass.cpp            |  8 +-------
 .../optional.object.ctor/move.pass.cpp               |  8 +-------
 .../optional.object.ctor/rvalue_T.pass.cpp           |  8 +-------
 .../optional.object.observe/value.pass.cpp           |  8 +-------
 .../optional.object.observe/value_const.pass.cpp     |  8 +-------
 .../value_const_rvalue.pass.cpp                      |  8 +-------
 .../optional.object.observe/value_rvalue.pass.cpp    |  8 +-------
 .../optional/optional.specalg/make_optional.pass.cpp | 12 +++---------
 .../bad_variant_access.pass.cpp                      |  8 +-------
 .../utilities/variant/variant.get/get_index.pass.cpp |  8 +-------
 .../utilities/variant/variant.get/get_type.pass.cpp  |  8 +-------
 .../variant.variant/variant.assign/T.pass.cpp        |  8 +-------
 .../variant.variant/variant.assign/copy.pass.cpp     |  8 +-------
 .../variant.variant/variant.assign/move.pass.cpp     |  8 +-------
 .../variant/variant.variant/variant.ctor/T.pass.cpp  |  9 +--------
 .../variant.variant/variant.ctor/copy.pass.cpp       |  8 +-------
 .../variant.variant/variant.ctor/default.pass.cpp    |  8 +-------
 .../variant.ctor/in_place_index_args.pass.cpp        |  8 +-------
 .../in_place_index_init_list_args.pass.cpp           |  9 +--------
 .../variant.ctor/in_place_type_args.pass.cpp         |  8 +-------
 .../in_place_type_init_list_args.pass.cpp            |  9 +--------
 .../variant.variant/variant.ctor/move.pass.cpp       |  8 +-------
 .../variant.mod/emplace_index_args.pass.cpp          |  8 +-------
 .../emplace_index_init_list_args.pass.cpp            |  8 +-------
 .../variant.mod/emplace_type_args.pass.cpp           |  8 +-------
 .../variant.mod/emplace_type_init_list_args.pass.cpp |  8 +-------
 .../variant.variant/variant.swap/swap.pass.cpp       |  8 +-------
 .../utilities/variant/variant.visit/visit.pass.cpp   |  8 +-------
 utils/libcxx/test/config.py                          | 12 ++++++++++++
 47 files changed, 65 insertions(+), 321 deletions(-)

diff --git a/docs/DesignDocs/AvailabilityMarkup.rst b/docs/DesignDocs/AvailabilityMarkup.rst
index 4e6d80b50..f076dfecd 100644
--- a/docs/DesignDocs/AvailabilityMarkup.rst
+++ b/docs/DesignDocs/AvailabilityMarkup.rst
@@ -51,6 +51,12 @@ or on a particular symbol:
 
     _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operator delete(void* __p, std::size_t __sz) _NOEXCEPT;
 
+Furthermore, a lit feature should be added to match that availability macro,
+so that tests depending on that feature can be marked to XFAIL if the feature
+is not supported. This way, the test suite will work on platforms that have
+not shipped the feature yet. This can be done by adding the appropriate lit
+feature in test/config.py.
+
 
 Testing
 =======
diff --git a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
index 6cf1efb86..68dae19b5 100644
--- a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.7
-// XFAIL: availability=macosx10.8
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.assign/move.pass.cpp b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
index 6e1b6d6a6..ffcfd1740 100644
--- a/test/std/utilities/any/any.class/any.assign/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.assign/value.pass.cpp b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
index 888a6a654..9cf1c90d2 100644
--- a/test/std/utilities/any/any.class/any.assign/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
index 318d9ecab..9d856942a 100644
--- a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
index 9684fcac7..87cc255e9 100644
--- a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/move.pass.cpp b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
index e75d56ef2..725308835 100644
--- a/test/std/utilities/any/any.class/any.cons/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/value.pass.cpp b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
index ed5884975..afc80635d 100644
--- a/test/std/utilities/any/any.class/any.cons/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
index 7cb5d4913..cbe7f63e3 100644
--- a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
index 0a01e8625..185d23823 100644
--- a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
index f4f5ee496..9986cc379 100644
--- a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
index 9b9ec4109..31ff1998f 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
index fb69f0d39..b0c87c6ff 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
index 1e9708545..b9701a82e 100644
--- a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/swap.pass.cpp b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
index cff34964a..bc420ee61 100644
--- a/test/std/utilities/any/any.nonmembers/swap.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_any_cast
 
 // <any>
 
diff --git a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
index 9bcfa8e46..6f119b274 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.7
-// XFAIL: availability=macosx10.8
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
index ac7be93f7..975d8678b 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
@@ -7,14 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
index f91cd110f..56f388258 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
@@ -8,13 +8,7 @@
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
index 1a7b36a5b..841d6124a 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
@@ -8,13 +8,7 @@
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index bf536ec63..0d3147e55 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
index 7fd1f2fa1..56b02b505 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
@@ -8,13 +8,7 @@
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
index 23fd85ba5..1fe00ce45 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
index 54bdc1001..b827e5e37 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
index b330bb8db..39db68ad4 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
@@ -8,13 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
index 06206a324..3778e9c69 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
@@ -9,13 +9,7 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <optional>
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
 // constexpr T& optional<T>::value() &&;
 
diff --git a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
index 772528927..3d407053f 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
@@ -7,16 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// <optional>
-
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_optional_access
 
+// <optional>
+//
 // template <class T>
 //   constexpr optional<decay_t<T>> make_optional(T&& v);
 
diff --git a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
index cb66771fc..4cb79a22c 100644
--- a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
+++ b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 
 // <variant>
diff --git a/test/std/utilities/variant/variant.get/get_index.pass.cpp b/test/std/utilities/variant/variant.get/get_index.pass.cpp
index 5519c4263..44a637ab3 100644
--- a/test/std/utilities/variant/variant.get/get_index.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_index.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.get/get_type.pass.cpp b/test/std/utilities/variant/variant.get/get_type.pass.cpp
index 76bbbb026..6ca827994 100644
--- a/test/std/utilities/variant/variant.get/get_type.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_type.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
index 6a4bb0486..c7dc6d6e3 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index c36375cf2..45b27fbd3 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -13,13 +13,7 @@
 // XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
 // XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index c213af4b2..fe9244830 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -13,13 +13,7 @@
 // XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
 // XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 
 // <variant>
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
index 4ebfe052d..61b877cdc 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -8,17 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
-
 // template <class ...Types> class variant;
 
 // template <class T> constexpr variant(T&&) noexcept(see below);
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index 00c94ee33..b8cc7b148 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
index 1766ee1db..582068dbb 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
index cb7d68a65..eea03c6a0 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
index 4b78bf569..6521c0c52 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
@@ -8,17 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
-
 // template <class ...Types> class variant;
 
 // template <size_t I, class Up, class ...Args>
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
index ab8fe0688..b2e6782d6 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
index 4061cfb25..dd7a81749 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
@@ -8,17 +8,10 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
-
 // template <class ...Types> class variant;
 
 // template <class Tp, class Up, class ...Args>
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index f146e16d3..4f962fdbc 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
index b688c8e7a..b745ee5bd 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
index 9d96a1dc2..8c826d3a0 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
index 0719f5e7b..faac06b81 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
index 49839eda4..00c15d79f 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
index 4e273f52e..1418cda44 100644
--- a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.visit/visit.pass.cpp b/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 15a1de984..b1fc8baea 100644
--- a/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -9,13 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: availability=macosx10.13
-// XFAIL: availability=macosx10.12
-// XFAIL: availability=macosx10.11
-// XFAIL: availability=macosx10.10
-// XFAIL: availability=macosx10.9
-// XFAIL: availability=macosx10.8
-// XFAIL: availability=macosx10.7
+// XFAIL: dylib-has-no-bad_variant_access
 
 // <variant>
 // template <class Visitor, class... Variants>
diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index a16bbdef5..5c7f4c367 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -1143,6 +1143,18 @@ class Configuration(object):
         self.lit_config.note(
             "computed target_triple as: %r" % self.config.target_triple)
 
+        # Throwing bad_optional_access, bad_variant_access and bad_any_cast is
+        # supported starting in macosx10.14.
+        if name == 'macosx' and version in ('10.%s' % v for v in range(7, 14)):
+            self.config.available_features.add('dylib-has-no-bad_optional_access')
+            self.lit_config.note("throwing bad_optional_access is not supported by the deployment target")
+
+            self.config.available_features.add('dylib-has-no-bad_variant_access')
+            self.lit_config.note("throwing bad_variant_access is not supported by the deployment target")
+
+            self.config.available_features.add('dylib-has-no-bad_any_cast')
+            self.lit_config.note("throwing bad_any_cast is not supported by the deployment target")
+
     def configure_env(self):
         self.target_info.configure_env(self.exec_env)
 
-- 
GitLab


From c6d9b0768b83fd772308b6937b5dab5cb32d5286 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 5 Feb 2019 19:50:17 +0000
Subject: [PATCH 113/137] [libc++] Use UNSUPPORTED instead of TEST_STD_VER
 #ifdef

When the whole test only works starting at some version of the Standard,
use UNSUPPORTED lit markup instead of #ifdef TEST_STD_VER. This provides
more visibility into the test suite.

Reviewed as https://reviews.llvm.org/D57704.
Thanks to Andrey Maksimov for the patch.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353206 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../iostream.format/quoted.manip/quoted.pass.cpp   | 14 +++-----------
 .../allocator_pointers.pass.cpp                    |  8 ++------
 .../default.allocator/allocator_pointers.pass.cpp  |  8 ++------
 .../meta.unary/meta.unary.cat/nullptr.pass.cpp     |  9 ++-------
 .../tuple/tuple.tuple/TupleFunction.pass.cpp       |  9 ++-------
 5 files changed, 11 insertions(+), 37 deletions(-)

diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
index 1e54e5657..b87797da5 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 // <iomanip>
 
 // quoted
@@ -15,10 +17,6 @@
 #include <string>
 #include <cassert>
 
-#include "test_macros.h"
-
-#if TEST_STD_VER > 11
-
 template <class CharT, class Traits>
 bool is_skipws ( const std::basic_istream<CharT, Traits>& is ) {
     return ( is.flags() & std::ios_base::skipws ) != 0;
@@ -173,12 +171,6 @@ int main(int, char**)
     assert ( unquote (  "" ) ==  "" ); // nothing there
     assert ( unquote ( L"" ) == L"" ); // nothing there
     test_padding ();
-    
-    return 0;
-}
 
-#else
-int main(int, char**) {
-  return 0;
+    return 0;
 }
-#endif
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
index 10475403d..e17a6e9c5 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
@@ -6,13 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 #include <scoped_allocator>
 #include <memory>
 #include <cassert>
 
-#include "test_macros.h"
-
-#if TEST_STD_VER >= 11
 // #include <memory>
 //
 // template <class Alloc>
@@ -121,6 +120,3 @@ int main(int, char**)
 
   return 0;
 }
-#else
-int main(int, char**) { return 0; }
-#endif
diff --git a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
index bc89c62a8..ad4319410 100644
--- a/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
@@ -6,12 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
-#include "test_macros.h"
-
-#if TEST_STD_VER >= 11
 // #include <memory>
 //
 // template <class Alloc>
@@ -120,6 +119,3 @@ int main(int, char**)
 
   return 0;
 }
-#else
-int main(int, char**) { return 0; }
-#endif
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
index 993b32fdf..0b25ac1ba 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
@@ -11,11 +11,11 @@
 // nullptr_t
 //  is_null_pointer
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <type_traits>
 #include <cstddef>        // for std::nullptr_t
-#include "test_macros.h"
 
-#if TEST_STD_VER > 11
 template <class T>
 void test_nullptr_imp()
 {
@@ -54,8 +54,3 @@ int main(int, char**)
     static_assert(!std::is_null_pointer<incomplete_type>::value, "");
     return 0;
 }
-#else
-int main(int, char**) {
-  return 0;
-}
-#endif
diff --git a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
index 27f3d5934..ede72c2a5 100644
--- a/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
@@ -6,11 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-// This is for bugs 18853 and 19118
-
-#include "test_macros.h"
+// UNSUPPORTED: c++98, c++03
 
-#if TEST_STD_VER >= 11
+// This is for bugs 18853 and 19118
 
 #include <tuple>
 #include <functional>
@@ -32,6 +30,3 @@ int main(int, char**)
 
   return 0;
 }
-#else
-int main(int, char**) { return 0; }
-#endif
-- 
GitLab


From fbc4ec4cc59e4eb9e8786b7e0e4ef25217903050 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Tue, 5 Feb 2019 19:50:47 +0000
Subject: [PATCH 114/137] [CMake] Support compiler-rt builtins library in tests

We're building tests with -nostdlib which means that we need to
explicitly include the builtins library. When using libgcc (default)
we can simply include -lgcc_s on the link line, but when using
compiler-rt builtins we need a complete path to the builtins library.

This path is already available in CMake as <PROJECT>_BUILTINS_LIBRARY,
so we just need to pass that path to lit and if config.compiler_rt is
true, link it to the test.

Prior to this patch, running tests when compiler-rt is being used as
the builtins library was broken as all tests would fail to link, but
with this change running tests when compiler-rt bultins library is
being used should be supported.

Differential Revision: https://reviews.llvm.org/D56701

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353208 91177308-0d34-0410-b5e6-96231b3b80d8
---
 docs/TestingLibcxx.rst           | 8 ++++++++
 test/lit.site.cfg.in             | 2 +-
 utils/libcxx/test/target_info.py | 6 ++++--
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/docs/TestingLibcxx.rst b/docs/TestingLibcxx.rst
index ebbbf628a..d8060fed1 100644
--- a/docs/TestingLibcxx.rst
+++ b/docs/TestingLibcxx.rst
@@ -183,6 +183,14 @@ configuration. Passing the option on the command line will override the default.
   option is specified or the environment variable LIBCXX_COLOR_DIAGNOSTICS is
   present then color diagnostics will be enabled.
 
+.. option:: llvm_unwinder
+
+  Enable the use of LLVM unwinder instead of libgcc.
+
+.. option:: builtins_library
+
+  Path to the builtins library to use instead of libgcc.
+
 
 Environment Variables
 ---------------------
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
index 019cca8a2..ed9a71105 100644
--- a/test/lit.site.cfg.in
+++ b/test/lit.site.cfg.in
@@ -27,7 +27,7 @@ config.test_compiler_flags      = "@LIBCXX_TEST_COMPILER_FLAGS@"
 
 config.executor                 = "@LIBCXX_EXECUTOR@"
 config.llvm_unwinder            = @LIBCXXABI_USE_LLVM_UNWINDER@
-config.compiler_rt              = @LIBCXX_USE_COMPILER_RT@
+config.builtins_library         = "@LIBCXX_BUILTINS_LIBRARY@"
 config.has_libatomic            = @LIBCXX_HAS_ATOMIC_LIB@
 config.use_libatomic            = @LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB@
 config.debug_build              = @LIBCXX_DEBUG_BUILD@
diff --git a/utils/libcxx/test/target_info.py b/utils/libcxx/test/target_info.py
index fb450805f..2ea24d62e 100644
--- a/utils/libcxx/test/target_info.py
+++ b/utils/libcxx/test/target_info.py
@@ -251,8 +251,10 @@ class LinuxLocalTI(DefaultTargetInfo):
             flags += ['-lunwind', '-ldl']
         else:
             flags += ['-lgcc_s']
-        compiler_rt = self.full_config.get_lit_bool('compiler_rt', False)
-        if not compiler_rt:
+        builtins_lib = self.full_config.get_lit_conf('builtins_library')
+        if builtins_lib:
+            flags += [builtins_lib]
+        else:
             flags += ['-lgcc']
         use_libatomic = self.full_config.get_lit_bool('use_libatomic', False)
         if use_libatomic:
-- 
GitLab


From 4806bce5a826d48990a3f14a1f3a058826082f68 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 5 Feb 2019 20:11:58 +0000
Subject: [PATCH 115/137] [libc++] Fix XFAILs on macOS when exceptions are
 disabled

Some tests are marked as failing on platforms where the dylib does not
provide the required exception classes. However, when testing with
exceptions disabled, those tests shouldn't be marked as failing.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353210 91177308-0d34-0410-b5e6-96231b3b80d8
---
 test/std/utilities/any/any.class/any.assign/copy.pass.cpp       | 2 +-
 test/std/utilities/any/any.class/any.assign/move.pass.cpp       | 2 +-
 test/std/utilities/any/any.class/any.assign/value.pass.cpp      | 2 +-
 test/std/utilities/any/any.class/any.cons/copy.pass.cpp         | 2 +-
 .../std/utilities/any/any.class/any.cons/in_place_type.pass.cpp | 2 +-
 test/std/utilities/any/any.class/any.cons/move.pass.cpp         | 2 +-
 test/std/utilities/any/any.class/any.cons/value.pass.cpp        | 2 +-
 test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp | 2 +-
 test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp   | 2 +-
 test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp    | 2 +-
 .../any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp       | 2 +-
 .../any/any.nonmembers/any.cast/any_cast_reference.pass.cpp     | 2 +-
 test/std/utilities/any/any.nonmembers/make_any.pass.cpp         | 2 +-
 test/std/utilities/any/any.nonmembers/swap.pass.cpp             | 2 +-
 .../optional/optional.bad_optional_access/default.pass.cpp      | 2 +-
 .../optional/optional.bad_optional_access/derive.pass.cpp       | 2 +-
 .../optional/optional.object/optional.object.ctor/U.pass.cpp    | 2 +-
 .../optional.object/optional.object.ctor/const_T.pass.cpp       | 2 +-
 .../optional/optional.object/optional.object.ctor/move.pass.cpp | 2 +-
 .../optional.object/optional.object.ctor/rvalue_T.pass.cpp      | 2 +-
 .../optional.object/optional.object.observe/value.pass.cpp      | 2 +-
 .../optional.object.observe/value_const.pass.cpp                | 2 +-
 .../optional.object.observe/value_const_rvalue.pass.cpp         | 2 +-
 .../optional.object.observe/value_rvalue.pass.cpp               | 2 +-
 .../utilities/optional/optional.specalg/make_optional.pass.cpp  | 2 +-
 .../variant.bad_variant_access/bad_variant_access.pass.cpp      | 2 +-
 test/std/utilities/variant/variant.get/get_index.pass.cpp       | 2 +-
 test/std/utilities/variant/variant.get/get_type.pass.cpp        | 2 +-
 .../utilities/variant/variant.variant/variant.assign/T.pass.cpp | 2 +-
 .../variant/variant.variant/variant.assign/copy.pass.cpp        | 2 +-
 .../variant/variant.variant/variant.assign/move.pass.cpp        | 2 +-
 .../utilities/variant/variant.variant/variant.ctor/T.pass.cpp   | 2 +-
 .../variant/variant.variant/variant.ctor/copy.pass.cpp          | 2 +-
 .../variant/variant.variant/variant.ctor/default.pass.cpp       | 2 +-
 .../variant.variant/variant.ctor/in_place_index_args.pass.cpp   | 2 +-
 .../variant.ctor/in_place_index_init_list_args.pass.cpp         | 2 +-
 .../variant.variant/variant.ctor/in_place_type_args.pass.cpp    | 2 +-
 .../variant.ctor/in_place_type_init_list_args.pass.cpp          | 2 +-
 .../variant/variant.variant/variant.ctor/move.pass.cpp          | 2 +-
 .../variant.variant/variant.mod/emplace_index_args.pass.cpp     | 2 +-
 .../variant.mod/emplace_index_init_list_args.pass.cpp           | 2 +-
 .../variant.variant/variant.mod/emplace_type_args.pass.cpp      | 2 +-
 .../variant.mod/emplace_type_init_list_args.pass.cpp            | 2 +-
 .../variant/variant.variant/variant.swap/swap.pass.cpp          | 2 +-
 test/std/utilities/variant/variant.visit/visit.pass.cpp         | 2 +-
 45 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
index 68dae19b5..d818400c5 100644
--- a/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/copy.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.assign/move.pass.cpp b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
index ffcfd1740..165cc0096 100644
--- a/test/std/utilities/any/any.class/any.assign/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/move.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.assign/value.pass.cpp b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
index 9cf1c90d2..8ca93df34 100644
--- a/test/std/utilities/any/any.class/any.assign/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.assign/value.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
index 9d856942a..fbb5f181a 100644
--- a/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/copy.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
index 87cc255e9..bfe86e800 100644
--- a/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/move.pass.cpp b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
index 725308835..3c0780c0a 100644
--- a/test/std/utilities/any/any.class/any.cons/move.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/move.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.cons/value.pass.cpp b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
index afc80635d..e39c7307e 100644
--- a/test/std/utilities/any/any.class/any.cons/value.pass.cpp
+++ b/test/std/utilities/any/any.class/any.cons/value.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
index cbe7f63e3..8a5e43378 100644
--- a/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
index 185d23823..a8ac0d601 100644
--- a/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
index 9986cc379..f49511138 100644
--- a/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
+++ b/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
index 31ff1998f..58f58afa9 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
index b0c87c6ff..121644480 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
index b9701a82e..9c5dda206 100644
--- a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/any/any.nonmembers/swap.pass.cpp b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
index bc420ee61..5461a4d0c 100644
--- a/test/std/utilities/any/any.nonmembers/swap.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/swap.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_any_cast
+// XFAIL: dylib-has-no-bad_any_cast && !libcpp-no-exceptions
 
 // <any>
 
diff --git a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
index 6f119b274..244d4617b 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
index 975d8678b..708d1c882 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
index 56f388258..b5966dfa5 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
index 841d6124a..f20a840b0 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index 0d3147e55..4c58d45b5 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
index 56b02b505..f2e7882e8 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
@@ -8,7 +8,7 @@
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
index 1fe00ce45..a37d0f34e 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
index b827e5e37..4533208d6 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
index 39db68ad4..9719a1ebd 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
index 3778e9c69..215db7f1b 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
@@ -9,7 +9,7 @@
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <optional>
 
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // constexpr T& optional<T>::value() &&;
 
diff --git a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
index 3d407053f..f93913e5b 100644
--- a/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
+++ b/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_optional_access
+// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
 
 // <optional>
 //
diff --git a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
index 4cb79a22c..ab2a9c429 100644
--- a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
+++ b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 
 // <variant>
diff --git a/test/std/utilities/variant/variant.get/get_index.pass.cpp b/test/std/utilities/variant/variant.get/get_index.pass.cpp
index 44a637ab3..4b04929a6 100644
--- a/test/std/utilities/variant/variant.get/get_index.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_index.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.get/get_type.pass.cpp b/test/std/utilities/variant/variant.get/get_type.pass.cpp
index 6ca827994..316213ed2 100644
--- a/test/std/utilities/variant/variant.get/get_type.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_type.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
index c7dc6d6e3..02498b1ac 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
index 45b27fbd3..820d81e71 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -13,7 +13,7 @@
 // XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
 // XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
index fe9244830..990e10c0f 100644
--- a/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -13,7 +13,7 @@
 // XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
 // XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 
 // <variant>
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
index 61b877cdc..73bd2c628 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
index b8cc7b148..4cd210d3d 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
index 582068dbb..579ae4d9f 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
index eea03c6a0..ac736fb3a 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
index 6521c0c52..179b66353 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
index b2e6782d6..430ddca3c 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
index dd7a81749..46dab74e8 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
index 4f962fdbc..d06b638e6 100644
--- a/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
index b745ee5bd..95f16ac2d 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
index 8c826d3a0..aee3c3fa1 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
index faac06b81..929806a09 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
index 00c15d79f..9cb9674f4 100644
--- a/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
index 1418cda44..8443f1e8e 100644
--- a/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ b/test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 
diff --git a/test/std/utilities/variant/variant.visit/visit.pass.cpp b/test/std/utilities/variant/variant.visit/visit.pass.cpp
index b1fc8baea..11e26d097 100644
--- a/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access
+// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
 
 // <variant>
 // template <class Visitor, class... Variants>
-- 
GitLab


From 5569a5e69c48d28f59bd0b5d57b84a5586ec3bbb Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 5 Feb 2019 20:55:23 +0000
Subject: [PATCH 116/137] [libc++] Fix XFAILs when exceptions are disabled

It turns out that I un-XFAILed too many tests in r353210: some tests
actually fail whether exceptions are enabled or not because they use
types that are marked as unavailable even when exceptions are disabled.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353215 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../optional/optional.bad_optional_access/default.pass.cpp      | 2 +-
 .../optional/optional.bad_optional_access/derive.pass.cpp       | 2 +-
 .../variant.bad_variant_access/bad_variant_access.pass.cpp      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
index 244d4617b..6f119b274 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
@@ -8,7 +8,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
index 708d1c882..975d8678b 100644
--- a/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
+++ b/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// XFAIL: dylib-has-no-bad_optional_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_optional_access
 
 // <optional>
 
diff --git a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
index ab2a9c429..4cb79a22c 100644
--- a/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
+++ b/test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
@@ -9,7 +9,7 @@
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// XFAIL: dylib-has-no-bad_variant_access && !libcpp-no-exceptions
+// XFAIL: dylib-has-no-bad_variant_access
 
 
 // <variant>
-- 
GitLab


From 4f9dc4d9cfbede47cd4cba9e280b2768cb478a9f Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Wed, 6 Feb 2019 16:10:25 +0000
Subject: [PATCH 117/137] Add a specialization for '__unwrap_iter' to handle
 const interators. This enables the 'memmove' optimization for std::copy, etc.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353311 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/algorithm | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/include/algorithm b/include/algorithm
index b52d44522..7da753a49 100644
--- a/include/algorithm
+++ b/include/algorithm
@@ -1610,6 +1610,18 @@ __unwrap_iter(__wrap_iter<_Tp*> __i)
     return __i.base();
 }
 
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
+typename enable_if
+<
+    is_trivially_copy_assignable<_Tp>::value,
+    const _Tp*
+>::type
+__unwrap_iter(__wrap_iter<const _Tp*> __i)
+{
+    return __i.base();
+}
+
 #else
 
 template <class _Tp>
-- 
GitLab


From 8fb436e97ec2cdd0e0550f54bd7789fde6cb26a3 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Wed, 6 Feb 2019 18:06:50 +0000
Subject: [PATCH 118/137] [libc++] Only add dylib-related features when using
 the system's libc++

Otherwise, when testing trunk libc++ on an older system, lit will think
that the dylib features are disabled. Ideally, we'd have a notion of
running the tests with/without a deployment target (or, equivalently,
a deployment target representing trunk where everything is as recent
as can be). Since we always have a deployment target right now (which
defaults to the current system), we only enable those features when
we're going to also be testing with the system libc++.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353319 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/libcxx/test/config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index 5c7f4c367..f086e6630 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -1145,7 +1145,7 @@ class Configuration(object):
 
         # Throwing bad_optional_access, bad_variant_access and bad_any_cast is
         # supported starting in macosx10.14.
-        if name == 'macosx' and version in ('10.%s' % v for v in range(7, 14)):
+        if self.get_lit_conf('use_system_cxx_lib') and name == 'macosx' and version in ('10.%s' % v for v in range(7, 14)):
             self.config.available_features.add('dylib-has-no-bad_optional_access')
             self.lit_config.note("throwing bad_optional_access is not supported by the deployment target")
 
-- 
GitLab


From 11b7c528853da85df5ca3dc17a230adeb9ca753c Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Wed, 6 Feb 2019 18:33:02 +0000
Subject: [PATCH 119/137] Revert "[libc++] Only add dylib-related features when
 using the system's libc++"

This reverts r353319, which broke our internal CI.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353321 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/libcxx/test/config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index f086e6630..5c7f4c367 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -1145,7 +1145,7 @@ class Configuration(object):
 
         # Throwing bad_optional_access, bad_variant_access and bad_any_cast is
         # supported starting in macosx10.14.
-        if self.get_lit_conf('use_system_cxx_lib') and name == 'macosx' and version in ('10.%s' % v for v in range(7, 14)):
+        if name == 'macosx' and version in ('10.%s' % v for v in range(7, 14)):
             self.config.available_features.add('dylib-has-no-bad_optional_access')
             self.lit_config.note("throwing bad_optional_access is not supported by the deployment target")
 
-- 
GitLab


From 0c922504853a5ef4c8ded9cedefd86ae1875fcdb Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Thu, 7 Feb 2019 18:53:58 +0000
Subject: [PATCH 120/137] Add UBSAN annotation to __hash_table::rehash; we
 don't do anything wrong, but UBSAN's checker flags it as suspicious. See
 PR38606. NFC

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353448 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/__hash_table | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/__hash_table b/include/__hash_table
index f6b789dc7..4409d6dc5 100644
--- a/include/__hash_table
+++ b/include/__hash_table
@@ -2371,6 +2371,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_merge_multi(
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n)
+_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
 {
     if (__n == 1)
         __n = 2;
-- 
GitLab


From b72412d276b6d43ee2f84f94417946e8abe0447a Mon Sep 17 00:00:00 2001
From: Marshall Clow <mclow.lists@gmail.com>
Date: Thu, 7 Feb 2019 19:03:48 +0000
Subject: [PATCH 121/137] Add static_asserts to tuple's comparison operators to
 enforce the requirement that the tuples be the same size. See PR39183 for an
 example where we give unexpected results for this bad input case. With this
 change, we will reject it at compile-time

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353450 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/tuple | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/tuple b/include/tuple
index 15cbf2689..f7e7ee194 100644
--- a/include/tuple
+++ b/include/tuple
@@ -1120,6 +1120,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
+    static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
     return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
 }
 
@@ -1163,6 +1164,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
+    static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
     return __tuple_less<sizeof...(_Tp)>()(__x, __y);
 }
 
-- 
GitLab


From 1603203e3293e0e87392690965b75f45662a8fe3 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Sat, 9 Feb 2019 02:50:09 +0000
Subject: [PATCH 122/137] [libcxx] Support runtimes and monorepo locations for
 tests

The test configuration support currently searches for libc++ sources
in <ROOT>/projects/libcxx. This change also additionally searches
<ROOT>/runtimes/libcxx (so called runtimes layout) and <ROOT>/libcxx
(monorepo layout).

This matches the logic we already use in CMake, for example:
https://github.com/llvm/llvm-project/blob/6fd4e7f/libcxx/CMakeLists.txt#L148

When the monorepo becomes the only supported layout in the future,
we can simplify this logic again.

Differential Revision: https://reviews.llvm.org/D57776

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353600 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/libcxx/test/config.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index 5c7f4c367..c619086b6 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -281,9 +281,15 @@ class Configuration(object):
         self.project_obj_root = self.get_lit_conf('project_obj_root')
         self.libcxx_obj_root = self.get_lit_conf('libcxx_obj_root')
         if not self.libcxx_obj_root and self.project_obj_root is not None:
-            possible_root = os.path.join(self.project_obj_root, 'projects', 'libcxx')
-            if os.path.isdir(possible_root):
-                self.libcxx_obj_root = possible_root
+            possible_roots = [
+                os.path.join(self.project_obj_root, 'libcxx'),
+                os.path.join(self.project_obj_root, 'projects', 'libcxx'),
+                os.path.join(self.project_obj_root, 'runtimes', 'libcxx'),
+            ]
+            for possible_root in possible_roots:
+                if os.path.isdir(possible_root):
+                    self.libcxx_obj_root = possible_root
+                    break
             else:
                 self.libcxx_obj_root = self.project_obj_root
 
-- 
GitLab


From e4dbc70699b480dc877b5bc02b276f722ba2f00d Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <n54@gmx.com>
Date: Sat, 9 Feb 2019 18:39:07 +0000
Subject: [PATCH 123/137] Mark another test as flaky

Reported on the NetBSD buildbot.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353622 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../thread.shared_mutex.class/try_lock.pass.cpp                 | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
index 09c7ad5f0..9d6b558ff 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
@@ -9,6 +9,8 @@
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+// FLAKY_TEST.
+
 // <shared_mutex>
 
 // class shared_mutex;
-- 
GitLab


From e8be8717a36db3802873dfd46727e9ff17cd49fe Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 10 Feb 2019 04:09:46 +0000
Subject: [PATCH 124/137] Add ABI list directories for 8.0

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353632 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/abi/8.0/x86_64-apple-darwin.v1.abilist    | 2360 +++++++++++++++++
 lib/abi/8.0/x86_64-apple-darwin.v2.abilist    | 2315 ++++++++++++++++
 .../8.0/x86_64-unknown-linux-gnu.v1.abilist   | 1861 +++++++++++++
 3 files changed, 6536 insertions(+)
 create mode 100644 lib/abi/8.0/x86_64-apple-darwin.v1.abilist
 create mode 100644 lib/abi/8.0/x86_64-apple-darwin.v2.abilist
 create mode 100644 lib/abi/8.0/x86_64-unknown-linux-gnu.v1.abilist

diff --git a/lib/abi/8.0/x86_64-apple-darwin.v1.abilist b/lib/abi/8.0/x86_64-apple-darwin.v1.abilist
new file mode 100644
index 000000000..65a034961
--- /dev/null
+++ b/lib/abi/8.0/x86_64-apple-darwin.v1.abilist
@@ -0,0 +1,2360 @@
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt10bad_typeid4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt10bad_typeid4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt11logic_error4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt11logic_error4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12bad_any_cast4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13bad_exception4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13bad_exception4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13runtime_error4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13runtime_error4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt16nested_exception14rethrow_nestedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt18bad_variant_access4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt19bad_optional_access4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110error_code7messageEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__decrementableEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__find_c_from_iEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__subscriptableEPKvl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__dereferenceableEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__find_c_and_lockEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db8__find_cEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db9__addableEPKvl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112bad_weak_ptr4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_scan_isEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE11do_scan_notEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEjw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEwc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112strstreambuf6pcountEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__113random_device7entropyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentERKNS_10error_codeEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category23default_error_conditionEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115error_condition7messageEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIcE15__do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIwE15__do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__XEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__cEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__rEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__xEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__am_pmEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__weeksEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE8__monthsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__XEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__cEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__rEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__xEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__am_pmEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__weeksEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE8__monthsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__124__libcpp_debug_exception4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_scan_isEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE11do_scan_notEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEPKwS3_Pj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEjw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEwc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale4nameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale9has_facetERNS0_2idE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale9use_facetERNS0_2idE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16localeeqERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE12do_transformEPKcS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE7do_hashEPKcS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE12do_transformEPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE7do_hashEPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18ios_base6getlocEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE8do_closeEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE8do_closeEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_truenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE12do_falsenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_truenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE12do_falsenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt8bad_cast4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt8bad_cast4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9bad_alloc4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9bad_alloc4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9exception4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9exception4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_erroraSERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC1ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC2ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptraSERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_erroraSERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110adopt_lockE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5alnumE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5alphaE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5blankE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5cntrlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5digitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5graphE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5lowerE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5printE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5punctE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5spaceE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5upperE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base6xdigitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110defer_lockE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE4intlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE4intlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE4intlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE4intlE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__call_onceERVmPvPFvS2_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_cEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_iEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db11__insert_icEPvPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db15__iterator_copyEPvPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db16__invalidate_allEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db4swapEPvS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_cEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_iEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__111try_to_lockE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__do_nothingEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__get_sp_mutEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__next_primeEm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112__rs_default4__c_E', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultclEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorC1ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorC2ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_1E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_2E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_3E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_4E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_5E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_6E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_7E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_8E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_9E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders3_10E', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf3strEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf4swapERS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf6__initEPclS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf6freezeEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf8overflowEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf9pbackfailEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf9underflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPFPvmEPFvS1_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKal'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKhl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPalS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPclS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPhlS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1El'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPFPvmEPFvS1_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKal'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKhl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPalS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPclS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPhlS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2El'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__113allocator_argE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreEli'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceclEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvEaSERKS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__get_const_dbEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__114__num_get_base5__srcE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base12__format_intEPcPKcbj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base14__format_floatEPcPKcj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_count12__add_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_count16__release_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__get_classnameEPKcb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115future_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcE6__initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwE6__initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115system_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116generic_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state12__make_readyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state16__on_zero_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4copyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4waitEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9__executeEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9set_valueEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117declare_reachableEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117iostream_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_allEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_oneEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variableD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variableD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118get_pointer_safetyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex11lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex13unlock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex15try_lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base11lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base13unlock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base15try_lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count10__add_weakEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count12__add_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count14__release_weakEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count16__release_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__thread_local_dataEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119declare_no_pointersEPcm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__119piecewise_constructE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__120__get_collation_nameEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__120__throw_system_errorEiPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121__throw_runtime_errorEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121__undeclare_reachableEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121undeclare_no_pointersEPcm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__123__libcpp_debug_functionE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__13cinE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14cerrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14clogE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14coutE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14wcinE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15alignEmmRPvRm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcE13classic_tableEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC1EPKjbm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC2EPKjbm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutexD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wcerrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wclogE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wcoutE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__itoa8__u32toaEjPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__itoa8__u64toaEyPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock3nowEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock9is_steadyE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock11from_time_tEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock3nowEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9is_steadyE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvE3getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16gslice6__initEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale2id5__getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale2id6__initEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale2id9__next_idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale3allE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale4noneE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale4timeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale5ctypeE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facet16__on_zero_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale6globalERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale7classicEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale7collateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale7numericE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale8__globalEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale8messagesE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale8monetaryE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_PKci'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_S2_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_PKci'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_S2_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeaSERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread20hardware_concurrencyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread4joinEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread6detachEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16threadD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16threadD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17collateIcE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17collateIwE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE10get_futureEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE24set_value_at_thread_exitEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE9set_valueEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvEC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvEC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_node5__addEPNS_8__i_nodeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__get_dbEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__i_nodeD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__i_nodeD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__rs_getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__sp_mut4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__sp_mut6unlockEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base10floatfieldE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base10scientificE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base11adjustfieldE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base15sync_with_stdioEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base16__call_callbacksENS0_5eventE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base2inE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3appE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3ateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3decE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3hexE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3octE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3outE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4initEPv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base4leftE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4moveERS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4swapERS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5clearEj'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5fixedE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5imbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5iwordEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5pwordEi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5rightE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5truncE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6badbitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6binaryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6eofbitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6skipwsE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base6xallocEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7copyfmtERKS0_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failbitE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7goodbitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7showposE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7unitbufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base8internalE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base8showbaseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9__xindex_E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9basefieldE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9boolalphaE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9showpointE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9uppercaseE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18messagesIcE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18messagesIwE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImE6resizeEmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt10unexpectedv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt10unexpectedv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt13get_terminatev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt13get_terminatev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt13set_terminatePFvvE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt13set_terminatePFvvE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt14get_unexpectedv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt14get_unexpectedv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt14set_unexpectedPFvvE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt14set_unexpectedPFvvE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt15get_new_handlerv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt15get_new_handlerv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt15set_new_handlerPFvvE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt15set_new_handlerPFvvE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17__throw_bad_allocv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17current_exceptionv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17rethrow_exceptionSt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt18uncaught_exceptionv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt19uncaught_exceptionsv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZSt7nothrow', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt9terminatev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt9terminatev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIDs'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental19bad_optional_accessE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110__time_getE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110__time_putE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110ctype_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110money_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_getIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_getIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_putIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_putIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111regex_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112bad_weak_ptrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112codecvt_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112future_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112strstreambufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112system_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113messages_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__num_get_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__num_put_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__shared_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114error_categoryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__assoc_sub_stateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__119__shared_weak_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__124__libcpp_debug_exceptionE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__15ctypeIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__15ctypeIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__16locale5facetE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17collateIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17collateIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18__c_nodeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18ios_base7failureE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18ios_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18messagesIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18messagesIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18numpunctIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18numpunctIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_getIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_getIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_putIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_putIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19strstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19time_baseE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt10bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt10bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt11logic_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt11logic_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt11range_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt11range_error'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt12bad_any_cast', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt12domain_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt12domain_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt12length_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt12length_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt12out_of_range'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt12out_of_range'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt13bad_exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt13bad_exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt13runtime_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt13runtime_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt14overflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt14overflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt15underflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt15underflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt16invalid_argument'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt16invalid_argument'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt16nested_exception', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt18bad_variant_access', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt19bad_optional_access', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt20bad_array_new_length'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt20bad_array_new_length'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt8bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt8bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt9bad_alloc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt9bad_alloc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt9exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt9exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt9type_info'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt9type_info'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTId'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTId'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental19bad_optional_accessE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110ctype_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110money_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__111regex_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112bad_weak_ptrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112codecvt_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112future_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112strstreambufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112system_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113messages_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114error_categoryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__15ctypeIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__15ctypeIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__16locale5facetE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17collateIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17collateIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18__c_nodeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18ios_base7failureE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18ios_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18messagesIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18messagesIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18numpunctIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18numpunctIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_getIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_getIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_putIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_putIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19strstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19time_baseE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt10bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt10bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11logic_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11logic_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11range_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11range_error'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt12bad_any_cast', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12domain_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12domain_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12length_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12length_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12out_of_range'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12out_of_range'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13bad_exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13bad_exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13runtime_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13runtime_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt14overflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt14overflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt15underflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt15underflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt16invalid_argument'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt16invalid_argument'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt16nested_exception', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt18bad_variant_access', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt19bad_optional_access', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt20bad_array_new_length'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt20bad_array_new_length'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt8bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt8bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9bad_alloc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9bad_alloc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9type_info'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9type_info'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSy'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__110istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__110ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__19strstreamE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental19bad_optional_accessE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__111regex_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112bad_weak_ptrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112future_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112strstreambufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112system_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__shared_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114error_categoryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__assoc_sub_stateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__119__shared_weak_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__124__libcpp_debug_exceptionE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__15ctypeIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__15ctypeIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__16locale5facetE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17collateIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17collateIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18__c_nodeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18ios_base7failureE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18ios_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18messagesIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18messagesIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18numpunctIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18numpunctIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19strstreamE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt10bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt10bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11logic_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11logic_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11range_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11range_error'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt12bad_any_cast', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12domain_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12domain_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12length_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12length_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12out_of_range'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12out_of_range'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13bad_exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13bad_exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13runtime_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13runtime_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt14overflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt14overflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt15underflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt15underflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt16invalid_argument'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt16invalid_argument'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt16nested_exception', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt18bad_variant_access', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt19bad_optional_access', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt20bad_array_new_length'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt20bad_array_new_length'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt8bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt8bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9bad_alloc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9bad_alloc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9type_info'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9type_info'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_tRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvmSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_tRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvmSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__Znam'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_tRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__Znwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_tRKSt9nothrow_t'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_allocate_exception'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_allocate_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_atexit'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_begin_catch'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_begin_catch'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_call_unexpected'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_call_unexpected'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_current_exception_type'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_current_exception_type'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_current_primary_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_decrement_exception_refcount'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_deleted_virtual'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_deleted_virtual'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_demangle'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_demangle'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_end_catch'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_end_catch'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_free_exception'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_free_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_get_exception_ptr'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_get_exception_ptr'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals_fast'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals_fast'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_abort'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_abort'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_acquire'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_acquire'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_release'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_release'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_increment_exception_refcount'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_pure_virtual'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_pure_virtual'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_rethrow'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow_primary_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_throw'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_throw'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_uncaught_exceptions'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cctor'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cctor'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cleanup'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cleanup'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_ctor'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_ctor'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete2'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete2'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete3'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete3'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_dtor'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_dtor'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new2'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new2'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new3'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new3'}
+{'type': 'U', 'is_defined': False, 'name': '___dynamic_cast'}
+{'type': 'I', 'is_defined': True, 'name': '___dynamic_cast'}
+{'type': 'U', 'is_defined': False, 'name': '___gxx_personality_v0'}
+{'type': 'I', 'is_defined': True, 'name': '___gxx_personality_v0'}
diff --git a/lib/abi/8.0/x86_64-apple-darwin.v2.abilist b/lib/abi/8.0/x86_64-apple-darwin.v2.abilist
new file mode 100644
index 000000000..5880a3bfd
--- /dev/null
+++ b/lib/abi/8.0/x86_64-apple-darwin.v2.abilist
@@ -0,0 +1,2315 @@
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt10bad_typeid4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt10bad_typeid4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt11logic_error4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt11logic_error4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12bad_any_cast4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13bad_exception4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13bad_exception4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13runtime_error4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13runtime_error4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt16nested_exception14rethrow_nestedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt18bad_variant_access4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt19bad_optional_access4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210__time_put8__do_putEPcRS1_PK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210__time_put8__do_putEPwRS1_PK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210error_code7messageEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__decrementableEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__find_c_from_iEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__subscriptableEPKvl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db17__dereferenceableEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db17__find_c_and_lockEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db22__less_than_comparableEPKvS2_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db8__find_cEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db9__addableEPKvl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212bad_weak_ptr4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_tolowerEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_tolowerEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_toupperEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_toupperEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_scan_isEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_tolowerEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_tolowerEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_toupperEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_toupperEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE11do_scan_notEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE5do_isEPKwS3_Pj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE5do_isEjw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE8do_widenEPKcS3_Pw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE8do_widenEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE9do_narrowEPKwS3_cPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE9do_narrowEwc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212strstreambuf6pcountEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__213random_device7entropyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIcE10do_compareEPKcS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIcE12do_transformEPKcS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIwE10do_compareEPKwS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIwE12do_transformEPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214error_category10equivalentERKNS_10error_codeEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214error_category10equivalentEiRKNS_15error_conditionE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214error_category23default_error_conditionEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215error_condition7messageEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217bad_function_call4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE13do_neg_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE13do_pos_formatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE14do_curr_symbolEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE14do_frac_digitsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_negative_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_positive_signEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__218__time_get_storageIcE15__do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__218__time_get_storageIwE15__do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__219__shared_weak_count13__get_deleterERKSt9type_info'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__XEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__cEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__rEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__xEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE7__am_pmEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE7__weeksEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE8__monthsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__XEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__cEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__rEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__xEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE7__am_pmEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE7__weeksEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE8__monthsEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__vector_base_commonILb1EE20__throw_length_errorEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__vector_base_commonILb1EE20__throw_out_of_rangeEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__221__basic_string_commonILb1EE20__throw_length_errorEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__221__basic_string_commonILb1EE20__throw_out_of_rangeEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__223__match_any_but_newlineIcE6__execERNS_7__stateIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__223__match_any_but_newlineIwE6__execERNS_7__stateIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__224__libcpp_debug_exception4whatEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_tolowerEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_tolowerEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_toupperEPcPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_toupperEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE8do_widenEPKcS3_Pc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE8do_widenEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE9do_narrowEPKcS3_cPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE9do_narrowEcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_scan_isEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_tolowerEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_tolowerEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_toupperEPwPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_toupperEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE11do_scan_notEjPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE5do_isEPKwS3_Pj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE5do_isEjw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE8do_widenEPKcS3_Pw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE8do_widenEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE9do_narrowEPKwS3_cPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE9do_narrowEwc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26locale4nameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26locale9has_facetERNS0_2idE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26locale9use_facetERNS0_2idE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26localeeqERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE11do_encodingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE13do_max_lengthEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE16do_always_noconvEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIcE10do_compareEPKcS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIcE12do_transformEPKcS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIcE7do_hashEPKcS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIwE10do_compareEPKwS3_S3_S3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIwE12do_transformEPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIwE7do_hashEPKwS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28ios_base6getlocEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIcE8do_closeEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIwE8do_closeEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE11do_truenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE12do_falsenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE11do_groupingEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE11do_truenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE12do_falsenameEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE16do_decimal_pointEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE16do_thousands_sepEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIcE10__do_widenERNS_8ios_baseEPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIcE12__do_widen_pERNS_8ios_baseEPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIwE10__do_widenERNS_8ios_baseEPw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIwE12__do_widen_pERNS_8ios_baseEPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt8bad_cast4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt8bad_cast4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9bad_alloc4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9bad_alloc4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9exception4whatEv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9exception4whatEv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_erroraSERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC1ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC2ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptraSERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKS_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_erroraSERKS_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210adopt_lockE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5alnumE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5alphaE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5blankE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5cntrlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5digitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5graphE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5lowerE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5printE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5punctE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5spaceE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5upperE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base6xdigitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210defer_lockE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210istrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210istrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210istrstreamD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb0EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb0EE4intlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb1EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb1EE4intlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb0EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb0EE4intlE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb1EE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb1EE4intlE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210ostrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210ostrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210ostrstreamD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__call_onceERVmPvPFvS2_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db10__insert_cEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db10__insert_iEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db11__insert_icEPvPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db15__iterator_copyEPvPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db16__invalidate_allEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db4swapEPvS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db9__erase_cEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db9__erase_iEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorC1ENS_15regex_constants10error_typeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorC2ENS_15regex_constants10error_typeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__211try_to_lockE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__do_nothingEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__get_sp_mutEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__next_primeEm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212__rs_default4__c_E', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC1ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC2ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultclEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorC1ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorC2ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_1E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_2E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_3E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_4E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_5E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_6E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_7E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_8E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_9E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders3_10E', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf3strEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf4swapERS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf6__initEPclS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf6freezeEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf7seekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf7seekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf8overflowEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf9pbackfailEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf9underflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPFPvmEPFvS1_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKal'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKhl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPalS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPclS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPhlS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1El'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPFPvmEPFvS1_E'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKal'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKhl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPalS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPclS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPhlS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2El'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__213allocator_argE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getEPclc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4peekEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4readEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5tellgEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5ungetEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6ignoreEli'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE7putbackEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getEPwlw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4peekEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4readEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5tellgEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5ungetEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6ignoreEli'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE7putbackEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE3putEc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE5flushEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE3putEw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE5flushEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEPKv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEs'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEt'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceclEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213shared_futureIvED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213shared_futureIvED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213shared_futureIvEaSERKS1_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__get_const_dbEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_get_base10__get_baseERNS_8ios_baseE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__214__num_get_base5__srcE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_put_base12__format_intEPcPKcbj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_put_base14__format_floatEPcPKcj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__shared_countD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__shared_countD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__shared_countD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214error_categoryD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214error_categoryD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214error_categoryD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__get_classnameEPKcb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE5uflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE8overflowEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9showmanycEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9underflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEaSERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE4swapERS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE4syncEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE5uflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE8overflowEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9showmanycEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9underflowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEaSERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215future_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcE6__initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwE6__initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215system_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216generic_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state12__make_readyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state13set_exceptionESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state16__on_zero_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state24set_value_at_thread_exitEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state4copyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state4waitEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state9__executeEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state9set_valueEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217bad_function_callD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217bad_function_callD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217bad_function_callD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217declare_reachableEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217iostream_categoryEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIcLb0EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIcLb1EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIwLb0EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIwLb1EE4initEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcE4initERKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwE4initERKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable10notify_allEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable10notify_oneEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable4waitERNS_11unique_lockINS_5mutexEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variableD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variableD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex11lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex13unlock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex15try_lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base11lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base13unlock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base15try_lock_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_baseC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_baseC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_count14__release_weakEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_count4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__thread_local_dataEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219declare_no_pointersEPcm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__219piecewise_constructE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__220__get_collation_nameEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__220__throw_system_errorEiPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221__throw_runtime_errorEPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221__undeclare_reachableEPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221undeclare_no_pointersEPcm'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__223__libcpp_debug_functionE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__225notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__229__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__229__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__23cinE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24cerrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24clogE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24coutE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24wcinE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25alignEmmRPvRm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcE13classic_tableEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcEC1EPKjbm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcEC2EPKjbm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutex4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutex6unlockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutex8try_lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutexD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutexD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wcerrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wclogE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wcoutE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIccEEPcEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIddEEPdEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIffEEPfEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIllEEPlEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessImmEEPmEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIssEEPsEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIttEEPtEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12steady_clock3nowEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26chrono12steady_clock9is_steadyE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock11from_time_tEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock3nowEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock9is_steadyE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvE3getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvEC1EPNS_17__assoc_sub_stateE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvEC2EPNS_17__assoc_sub_stateE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26gslice6__initEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale14__install_ctorERKS0_PNS0_5facetEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale2id5__getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale2id6__initEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale2id9__next_idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale3allE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale4noneE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale4timeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale5ctypeE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facet16__on_zero_sharedEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facetD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facetD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facetD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale6globalERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale7classicEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale7collateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale7numericE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale8__globalEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale8messagesE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale8monetaryE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_PKci'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_S2_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2EPKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_PKci'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_S2_i'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeaSERKS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26thread20hardware_concurrencyEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26thread4joinEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26thread6detachEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26threadD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26threadD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC1EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC2EPKcm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27collateIcE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIcED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27collateIwE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIwED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE10get_futureEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE13set_exceptionESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE24set_value_at_thread_exitEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE28set_exception_at_thread_exitESt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE9set_valueEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvEC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvEC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_node5__addEPNS_8__i_nodeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_nodeD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_nodeD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_nodeD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__get_dbEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__i_nodeD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__i_nodeD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__rs_getEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__sp_mut4lockEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__sp_mut6unlockEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base10floatfieldE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base10scientificE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base11adjustfieldE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base15sync_with_stdioEb'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base16__call_callbacksENS0_5eventE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base17register_callbackEPFvNS0_5eventERS0_iEi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base2inE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base33__set_badbit_and_consider_rethrowEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base34__set_failbit_and_consider_rethrowEv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3appE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3ateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3decE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3hexE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3octE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3outE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitC1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitC2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4initEPv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base4leftE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4moveERS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4swapERS0_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5clearEj'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base5fixedE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5imbueERKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5iwordEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5pwordEi'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base5rightE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base5truncE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6badbitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6binaryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6eofbitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6skipwsE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base6xallocEv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7copyfmtERKS0_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failbitE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC1EPKcRKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC2EPKcRKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7goodbitE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7showposE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7unitbufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base8internalE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base8showbaseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9__xindex_E', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9basefieldE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9boolalphaE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9showpointE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9uppercaseE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_baseD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_baseD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_baseD2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28messagesIcE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28messagesIwE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImE6resizeEmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_PKc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_prepERNS_8ios_baseERc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_PKw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE17__stage2_int_prepERNS_8ios_baseERw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED2Ev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29strstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29strstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29strstreamD2Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEd'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEe'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEf'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEi'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEj'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEl'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEx'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEy'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__2plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD0Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD0Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD1Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD1Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD2Ev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD2Ev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt10unexpectedv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt10unexpectedv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt13get_terminatev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt13get_terminatev'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt13set_terminatePFvvE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt13set_terminatePFvvE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt14get_unexpectedv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt14get_unexpectedv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt14set_unexpectedPFvvE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt14set_unexpectedPFvvE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt15get_new_handlerv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt15get_new_handlerv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt15set_new_handlerPFvvE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt15set_new_handlerPFvvE'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17__throw_bad_allocv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17current_exceptionv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17rethrow_exceptionSt13exception_ptr'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt18uncaught_exceptionv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt19uncaught_exceptionsv'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZSt7nothrow', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZSt9terminatev'}
+{'type': 'I', 'is_defined': True, 'name': '__ZSt9terminatev'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__210istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__210ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__29strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__29strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__29strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIDs'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental19bad_optional_accessE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210__time_getE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210__time_putE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210ctype_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210money_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_getIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_getIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_putIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_putIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211regex_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212bad_weak_ptrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212codecvt_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212ctype_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212ctype_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212future_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212strstreambufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212system_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213messages_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__num_get_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__num_put_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__shared_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214collate_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214collate_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214error_categoryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215messages_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215messages_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215numpunct_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215numpunct_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__216__narrow_to_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__216__narrow_to_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217__assoc_sub_stateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217__widen_from_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217__widen_from_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217bad_function_callE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__218__time_get_storageIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__218__time_get_storageIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__219__shared_weak_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__time_get_c_storageIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__time_get_c_storageIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__224__libcpp_debug_exceptionE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__25ctypeIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__25ctypeIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__26locale5facetE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27collateIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27collateIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28__c_nodeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28ios_base7failureE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28ios_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28messagesIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28messagesIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28numpunctIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28numpunctIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_getIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_getIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_putIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_putIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29strstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29time_baseE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPKy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPKy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIPy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIPy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt10bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt10bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt11logic_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt11logic_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt11range_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt11range_error'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt12bad_any_cast', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt12domain_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt12domain_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt12length_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt12length_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt12out_of_range'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt12out_of_range'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt13bad_exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt13bad_exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt13runtime_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt13runtime_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt14overflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt14overflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt15underflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt15underflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt16invalid_argument'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt16invalid_argument'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt16nested_exception', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt18bad_variant_access', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt19bad_optional_access', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt20bad_array_new_length'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt20bad_array_new_length'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt8bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt8bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt9bad_alloc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt9bad_alloc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt9exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt9exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTISt9type_info'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTISt9type_info'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTId'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTId'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTIy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTIy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental19bad_optional_accessE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210__time_getE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210__time_putE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210ctype_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210money_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_getIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_getIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_putIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_putIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211regex_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212bad_weak_ptrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212codecvt_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212ctype_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212ctype_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212future_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212strstreambufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212system_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213messages_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__num_get_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__num_put_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__shared_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214collate_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214collate_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214error_categoryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215messages_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215messages_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215numpunct_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215numpunct_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__216__narrow_to_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__216__narrow_to_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217__assoc_sub_stateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217__widen_from_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217__widen_from_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217bad_function_callE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__218__time_get_storageIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__218__time_get_storageIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__219__shared_weak_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__time_get_c_storageIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__time_get_c_storageIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__224__libcpp_debug_exceptionE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__25ctypeIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__25ctypeIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__26locale5facetE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27collateIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27collateIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28__c_nodeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28ios_base7failureE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28ios_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28messagesIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28messagesIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28numpunctIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28numpunctIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_getIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_getIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_putIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_putIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29strstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29time_baseE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDn'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDn'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPKy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPKy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSPy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSPy'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt10bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt10bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11logic_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11logic_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11range_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11range_error'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt12bad_any_cast', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12domain_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12domain_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12length_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12length_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12out_of_range'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12out_of_range'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13bad_exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13bad_exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13runtime_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13runtime_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt14overflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt14overflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt15underflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt15underflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt16invalid_argument'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt16invalid_argument'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt16nested_exception', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt18bad_variant_access', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt19bad_optional_access', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt20bad_array_new_length'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt20bad_array_new_length'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt8bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt8bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9bad_alloc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9bad_alloc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9type_info'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9type_info'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSa'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSa'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSb'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSb'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSd'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSd'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSe'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSe'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSf'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSf'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSh'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSh'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSi'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSi'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSj'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSj'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSl'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSl'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSm'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSm'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSs'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSs'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSt'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSt'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSv'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSv'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSw'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSw'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSx'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSx'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTSy'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTSy'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__210istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__210ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__29strstreamE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental19bad_optional_accessE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210istrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210ostrstreamE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__211regex_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212bad_weak_ptrE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212ctype_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212ctype_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212future_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212strstreambufE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212system_errorE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__shared_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214collate_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214collate_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214error_categoryE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215messages_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215messages_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215numpunct_bynameIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215numpunct_bynameIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__216__narrow_to_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__216__narrow_to_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217__assoc_sub_stateE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217__widen_from_utf8ILm16EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217__widen_from_utf8ILm32EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217bad_function_callE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIcLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIcLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIwLb0EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIwLb1EEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__219__shared_weak_countE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__224__libcpp_debug_exceptionE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__25ctypeIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__25ctypeIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__26locale5facetE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIDic11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIcc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIwc11__mbstate_tEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27collateIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27collateIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28__c_nodeE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28ios_base7failureE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28ios_baseE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28messagesIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28messagesIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28numpunctIcEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28numpunctIwEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29strstreamE', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt10bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt10bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11logic_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11logic_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11range_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11range_error'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt12bad_any_cast', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12domain_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12domain_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12length_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12length_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12out_of_range'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12out_of_range'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13bad_exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13bad_exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13runtime_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13runtime_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt14overflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt14overflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt15underflow_error'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt15underflow_error'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt16invalid_argument'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt16invalid_argument'}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt16nested_exception', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt18bad_variant_access', 'size': 0}
+{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt19bad_optional_access', 'size': 0}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt20bad_array_new_length'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt20bad_array_new_length'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt8bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt8bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9bad_alloc'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9bad_alloc'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9exception'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9exception'}
+{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9type_info'}
+{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9type_info'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__29strstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__29strstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210istrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210istrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210ostrstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210ostrstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__29strstreamD0Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__29strstreamD1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_tRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvmSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPv'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_tRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvmSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__Znam'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_tRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__Znwm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmRKSt9nothrow_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_t'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_tRKSt9nothrow_t'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_allocate_exception'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_allocate_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_atexit'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_cast'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_cast'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_typeid'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_typeid'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_begin_catch'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_begin_catch'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_call_unexpected'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_call_unexpected'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_current_exception_type'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_current_exception_type'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_current_primary_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_decrement_exception_refcount'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_deleted_virtual'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_deleted_virtual'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_demangle'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_demangle'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_end_catch'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_end_catch'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_free_exception'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_free_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_get_exception_ptr'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_get_exception_ptr'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals_fast'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals_fast'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_abort'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_abort'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_acquire'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_acquire'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_release'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_release'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_increment_exception_refcount'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_pure_virtual'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_pure_virtual'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_rethrow'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow_primary_exception'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_throw'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_throw'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_uncaught_exceptions'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cctor'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cctor'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cleanup'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cleanup'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_ctor'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_ctor'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete2'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete2'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete3'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete3'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_dtor'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_dtor'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new2'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new2'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new3'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new3'}
+{'type': 'U', 'is_defined': False, 'name': '___dynamic_cast'}
+{'type': 'I', 'is_defined': True, 'name': '___dynamic_cast'}
+{'type': 'U', 'is_defined': False, 'name': '___gxx_personality_v0'}
+{'type': 'I', 'is_defined': True, 'name': '___gxx_personality_v0'}
diff --git a/lib/abi/8.0/x86_64-unknown-linux-gnu.v1.abilist b/lib/abi/8.0/x86_64-unknown-linux-gnu.v1.abilist
new file mode 100644
index 000000000..0be9eb2fc
--- /dev/null
+++ b/lib/abi/8.0/x86_64-unknown-linux-gnu.v1.abilist
@@ -0,0 +1,1861 @@
+{'name': '_ZNKSt11logic_error4whatEv', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNKSt12bad_any_cast4whatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt13runtime_error4whatEv', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNKSt16nested_exception14rethrow_nestedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt18bad_variant_access4whatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt19bad_optional_access4whatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110error_code7messageEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db15__decrementableEPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db15__find_c_from_iEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db15__subscriptableEPKvl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db17__dereferenceableEPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db17__find_c_and_lockEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db8__find_cEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__111__libcpp_db9__addableEPKvl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112bad_weak_ptr4whatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE10do_scan_isEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE11do_scan_notEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE5do_isEtw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEwc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__112strstreambuf6pcountEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__113random_device7entropyEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IwE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114error_category10equivalentERKNS_10error_codeEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__114error_category23default_error_conditionEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__115error_condition7messageEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__118__time_get_storageIcE15__do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__118__time_get_storageIwE15__do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIcE3__XEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIcE3__cEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIcE3__rEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIcE3__xEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIcE7__am_pmEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIcE7__weeksEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIcE8__monthsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIwE3__XEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIwE3__cEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIwE3__rEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIwE3__xEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIwE7__am_pmEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIwE7__weeksEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__time_get_c_storageIwE8__monthsEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__124__libcpp_debug_exception4whatEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE10do_tolowerEPcPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE10do_tolowerEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE10do_toupperEPcPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE10do_toupperEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE8do_widenEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIcE9do_narrowEcc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE10do_scan_isEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE10do_tolowerEPwPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE10do_tolowerEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE10do_toupperEPwPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE10do_toupperEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE11do_scan_notEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE5do_isEPKwS3_Pt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE5do_isEtw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE8do_widenEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__15ctypeIwE9do_narrowEwc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__16locale4nameEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__16locale9has_facetERNS0_2idE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__16locale9use_facetERNS0_2idE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__16localeeqERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17collateIcE12do_transformEPKcS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17collateIcE7do_hashEPKcS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17collateIwE12do_transformEPKwS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17collateIwE7do_hashEPKwS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18ios_base6getlocEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18messagesIcE8do_closeEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18messagesIwE8do_closeEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIcE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIcE11do_truenameEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIcE12do_falsenameEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIcE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIcE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIwE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIwE11do_truenameEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIwE12do_falsenameEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIwE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18numpunctIwE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_errorC1EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_errorC1ERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_errorC2EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_errorC2ERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_errorD2Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt11logic_erroraSERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt12experimental19bad_optional_accessD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt12experimental19bad_optional_accessD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt12experimental19bad_optional_accessD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt12length_errorD1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt12out_of_rangeD1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt13exception_ptrC1ERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13exception_ptrC2ERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13exception_ptrD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13exception_ptrD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13exception_ptraSERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorC1EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorC1ERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorC2EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorC2ERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorD1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_errorD2Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt13runtime_erroraSERKS_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt14overflow_errorD1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt16invalid_argumentD1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt16nested_exceptionC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt16nested_exceptionC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt16nested_exceptionD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt16nested_exceptionD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt16nested_exceptionD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt19bad_optional_accessD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt19bad_optional_accessD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt19bad_optional_accessD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_getC1EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_getC2EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_getD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_getD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_putC1EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_putC2EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_putD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110__time_putD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110adopt_lockE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__110ctype_base5alnumE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5alphaE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5blankE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5cntrlE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5digitE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5graphE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5lowerE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5printE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5punctE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5spaceE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base5upperE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110ctype_base6xdigitE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
+{'name': '_ZNSt3__110defer_lockE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__110istrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110istrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110istrstreamD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110moneypunctIcLb0EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__110moneypunctIcLb0EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__110moneypunctIcLb1EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__110moneypunctIcLb1EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__110moneypunctIwLb0EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__110moneypunctIwLb0EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__110moneypunctIwLb1EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__110moneypunctIwLb1EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__110ostrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110ostrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110ostrstreamD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__110to_wstringEy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__call_onceERVmPvPFvS2_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db10__insert_cEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db10__insert_iEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db11__insert_icEPvPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db15__iterator_copyEPvPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db16__invalidate_allEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db4swapEPvS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db9__erase_cEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_db9__erase_iEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_dbC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_dbC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_dbD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__libcpp_dbD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111regex_errorD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111regex_errorD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111regex_errorD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111timed_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111timed_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111timed_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111timed_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111timed_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111timed_mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111timed_mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__111try_to_lockE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112__do_nothingEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__get_sp_mutEPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__next_primeEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__rs_default4__c_E', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__112__rs_defaultC1ERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__rs_defaultC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__rs_defaultC2ERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__rs_defaultC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__rs_defaultD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__rs_defaultD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112__rs_defaultclEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112bad_weak_ptrD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112bad_weak_ptrD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112bad_weak_ptrD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'is_defined': True, 'type': 'OBJECT', 'size': 8}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'is_defined': True, 'type': 'OBJECT', 'size': 8}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIcEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIcEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIwEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIwEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112ctype_bynameIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112future_errorC1ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112future_errorC2ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112future_errorD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112future_errorD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112future_errorD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112placeholders2_1E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_2E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_3E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_4E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_5E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_6E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_7E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_8E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders2_9E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112placeholders3_10E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__112strstreambuf3strEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf4swapERS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf6__initEPclS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf6freezeEb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf8overflowEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf9pbackfailEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambuf9underflowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1EPFPvmEPFvS1_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1EPKal', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1EPKcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1EPKhl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1EPalS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1EPclS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1EPhlS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC1El', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2EPFPvmEPFvS1_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2EPKal', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2EPKcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2EPKhl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2EPalS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2EPclS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2EPhlS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufC2El', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112strstreambufD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC1ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC1ENS_10error_codeEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC2ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC2ENS_10error_codeEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__112system_errorD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113allocator_argE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreElj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113random_deviceD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113random_deviceD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113random_deviceclEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113shared_futureIvED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113shared_futureIvED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__113shared_futureIvEaSERKS1_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__get_const_dbEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__num_get_base5__srcE', 'is_defined': True, 'type': 'OBJECT', 'size': 33}
+{'name': '_ZNSt3__114__num_put_base12__format_intEPcPKcbj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__num_put_base14__format_floatEPcPKcj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__shared_count12__add_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__shared_count16__release_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__shared_countD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__shared_countD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114__shared_countD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIcEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIcEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIwEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIwEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114collate_bynameIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114error_categoryC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114error_categoryD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114error_categoryD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__114error_categoryD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115__get_classnameEPKcb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115__thread_structC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115__thread_structC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115__thread_structD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115__thread_structD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115future_categoryEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcE6__initEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwE6__initEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115numpunct_bynameIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115recursive_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115recursive_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115recursive_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115recursive_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115recursive_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115recursive_mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115recursive_mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__115system_categoryEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116__narrow_to_utf8ILm16EED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116__narrow_to_utf8ILm16EED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116__narrow_to_utf8ILm16EED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116__narrow_to_utf8ILm32EED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116__narrow_to_utf8ILm32EED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116__narrow_to_utf8ILm32EED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__116generic_categoryEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state12__make_readyEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state16__on_zero_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state4copyEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state4waitEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state9__executeEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__assoc_sub_state9set_valueEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__widen_from_utf8ILm16EED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__widen_from_utf8ILm16EED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__widen_from_utf8ILm16EED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__widen_from_utf8ILm32EED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__widen_from_utf8ILm32EED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117__widen_from_utf8ILm32EED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117declare_reachableEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117iostream_categoryEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIcEC1EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIcEC2EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIwEC1EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIwEC2EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118condition_variable10notify_allEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118condition_variable10notify_oneEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118condition_variableD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118condition_variableD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118get_pointer_safetyEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutex11lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutex13unlock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutex15try_lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__118shared_timed_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_base11lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_base13unlock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_base15try_lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_base4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_base6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_base8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_baseC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_mutex_baseC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_count10__add_weakEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_count12__add_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_count14__release_weakEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_count16__release_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_count4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_countD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_countD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__shared_weak_countD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119__thread_local_dataEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119declare_no_pointersEPcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__119piecewise_constructE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__120__get_collation_nameEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__120__throw_system_errorEiPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121__throw_runtime_errorEPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121__undeclare_reachableEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121recursive_timed_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121recursive_timed_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121recursive_timed_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121recursive_timed_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121recursive_timed_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121recursive_timed_mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121recursive_timed_mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__121undeclare_no_pointersEPcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__123__libcpp_debug_functionE', 'is_defined': True, 'type': 'OBJECT', 'size': 8}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__124__libcpp_debug_exceptionD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__13cinE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
+{'name': '_ZNSt3__14cerrE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
+{'name': '_ZNSt3__14clogE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
+{'name': '_ZNSt3__14coutE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
+{'name': '_ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__14wcinE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
+{'name': '_ZNSt3__15alignEmmRPvRm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcE13classic_tableEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcE21__classic_lower_tableEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcE21__classic_upper_tableEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__15ctypeIcEC1EPKtbm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcEC2EPKtbm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__15ctypeIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15ctypeIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__15wcerrE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
+{'name': '_ZNSt3__15wclogE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
+{'name': '_ZNSt3__15wcoutE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
+{'name': '_ZNSt3__16__clocEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__itoa8__u64toaEmPc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__itoa8__u32toaEjPc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16chrono12steady_clock3nowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16chrono12steady_clock9is_steadyE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__16chrono12system_clock11from_time_tEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16chrono12system_clock3nowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16chrono12system_clock9is_steadyE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16futureIvE3getEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16futureIvED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16futureIvED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16gslice6__initEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale2id5__getEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale2id6__initEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale2id9__next_idE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale3allE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale4noneE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale4timeE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale5ctypeE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale5facet16__on_zero_sharedEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale5facetD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale5facetD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale5facetD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale6globalERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale7classicEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale7collateE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale7numericE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale8__globalEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16locale8messagesE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16locale8monetaryE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__16localeC1EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC1ERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC1ERKS0_PKci', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC1ERKS0_S2_i', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC2EPKc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC2ERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC2ERKS0_PKci', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC2ERKS0_S2_i', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16localeaSERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16thread20hardware_concurrencyEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16thread4joinEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16thread6detachEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16threadD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__16threadD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17codecvtIDic11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIDic11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIDic11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17codecvtIcc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIcc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIcc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17codecvtIwc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17collateIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17collateIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17collateIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17collateIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17collateIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17collateIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17collateIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17collateIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__17promiseIvE10get_futureEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvE24set_value_at_thread_exitEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvE9set_valueEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvEC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvEC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__17promiseIvED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__c_node5__addEPNS_8__i_nodeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__c_nodeD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__c_nodeD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__c_nodeD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__get_dbEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__i_nodeD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__i_nodeD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__rs_getEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__sp_mut4lockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18__sp_mut6unlockEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base10floatfieldE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base10scientificE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base11adjustfieldE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base15sync_with_stdioEb', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base16__call_callbacksENS0_5eventE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base2inE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base3appE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base3ateE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base3decE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base3hexE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base3octE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base3outE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base4InitC1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base4InitC2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base4InitD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base4InitD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base4initEPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base4leftE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base4moveERS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base4swapERS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base5clearEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base5fixedE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base5imbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base5iwordEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base5pwordEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base5rightE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base5truncE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base6badbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base6binaryE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base6eofbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base6skipwsE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base6xallocEv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7copyfmtERKS0_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7failbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7failureD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7failureD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7failureD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_base7goodbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base7showposE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base7unitbufE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base8internalE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base8showbaseE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base9__xindex_E', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base9basefieldE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base9boolalphaE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base9showpointE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_base9uppercaseE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
+{'name': '_ZNSt3__18ios_baseD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_baseD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18ios_baseD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18messagesIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18messagesIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18numpunctIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18numpunctIcEC1Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIcEC2Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18numpunctIwEC1Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIwEC2Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18numpunctIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__18valarrayImE6resizeEmm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18valarrayImEC1Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18valarrayImEC2Em', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18valarrayImED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__18valarrayImED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZNSt3__19strstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19strstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19strstreamD2Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEd', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEe', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEf', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEi', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEj', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEl', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEx', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__19to_stringEy', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZNSt8bad_castC1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt8bad_castD1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt8bad_castD2Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt9bad_allocC1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt9bad_allocD1Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZNSt9exceptionD2Ev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZSt15get_new_handlerv', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZSt17__throw_bad_allocv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZSt17current_exceptionv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZSt17rethrow_exceptionSt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZSt18uncaught_exceptionv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZSt19uncaught_exceptionsv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZSt7nothrow', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
+{'name': '_ZSt9terminatev', 'is_defined': False, 'type': 'FUNC'}
+{'name': '_ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 120}
+{'name': '_ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTINSt12experimental15fundamentals_v112bad_any_castE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt12experimental19bad_optional_accessE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__110__time_getE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__110__time_putE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__110ctype_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__110money_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__110moneypunctIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__110moneypunctIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__110moneypunctIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__110moneypunctIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__111__money_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__111__money_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__111__money_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__111__money_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__111regex_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__112bad_weak_ptrE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__112codecvt_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__112ctype_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__112ctype_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__112future_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__112strstreambufE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__112system_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__113messages_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__114__codecvt_utf8IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114__codecvt_utf8IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114__codecvt_utf8IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114__num_get_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__114__num_put_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__114__shared_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114collate_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114collate_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__114error_categoryE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115__codecvt_utf16IwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115__codecvt_utf16IwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__115messages_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115messages_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115numpunct_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115numpunct_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__116__narrow_to_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__116__narrow_to_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__117__assoc_sub_stateE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__117__widen_from_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__117__widen_from_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__117moneypunct_bynameIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__117moneypunct_bynameIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__117moneypunct_bynameIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__117moneypunct_bynameIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__118__time_get_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__118__time_get_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__119__shared_weak_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__120__codecvt_utf8_utf16IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__120__time_get_c_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__120__time_get_c_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__124__libcpp_debug_exceptionE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__15ctypeIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__15ctypeIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__16locale5facetE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__17codecvtIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__17codecvtIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__17codecvtIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__17collateIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__17collateIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__18__c_nodeE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__18ios_base7failureE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__18ios_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTINSt3__18messagesIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__18messagesIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__18numpunctIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__18numpunctIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 72}
+{'name': '_ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 72}
+{'name': '_ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__19__num_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__19__num_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__19__num_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__19__num_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTINSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTINSt3__19time_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTISt11logic_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt12bad_any_cast', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTISt12length_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt12out_of_range', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt13runtime_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt14overflow_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt16invalid_argument', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt16nested_exception', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTISt18bad_variant_access', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTISt19bad_optional_access', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTISt8bad_cast', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt9bad_alloc', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTISt9exception', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'is_defined': True, 'type': 'OBJECT', 'size': 50}
+{'name': '_ZTSNSt12experimental19bad_optional_accessE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTSNSt3__110__time_getE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__110__time_putE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__110ctype_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__110money_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__110moneypunctIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__110moneypunctIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__110moneypunctIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__110moneypunctIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__111__money_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__111__money_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__111__money_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__111__money_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__111regex_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
+{'name': '_ZTSNSt3__112bad_weak_ptrE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
+{'name': '_ZTSNSt3__112codecvt_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
+{'name': '_ZTSNSt3__112ctype_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 26}
+{'name': '_ZTSNSt3__112ctype_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 26}
+{'name': '_ZTSNSt3__112future_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
+{'name': '_ZTSNSt3__112strstreambufE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
+{'name': '_ZTSNSt3__112system_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
+{'name': '_ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
+{'name': '_ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
+{'name': '_ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
+{'name': '_ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
+{'name': '_ZTSNSt3__113messages_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTSNSt3__114__codecvt_utf8IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
+{'name': '_ZTSNSt3__114__codecvt_utf8IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
+{'name': '_ZTSNSt3__114__codecvt_utf8IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__114__num_get_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__114__num_put_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__114__shared_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
+{'name': '_ZTSNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 43}
+{'name': '_ZTSNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 43}
+{'name': '_ZTSNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
+{'name': '_ZTSNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
+{'name': '_ZTSNSt3__114collate_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__114collate_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__114error_categoryE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
+{'name': '_ZTSNSt3__115__codecvt_utf16IDiLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__115__codecvt_utf16IDiLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__115__codecvt_utf16IDsLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__115__codecvt_utf16IDsLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__115__codecvt_utf16IwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 33}
+{'name': '_ZTSNSt3__115__codecvt_utf16IwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 33}
+{'name': '_ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 49}
+{'name': '_ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 49}
+{'name': '_ZTSNSt3__115messages_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
+{'name': '_ZTSNSt3__115messages_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
+{'name': '_ZTSNSt3__115numpunct_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
+{'name': '_ZTSNSt3__115numpunct_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
+{'name': '_ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
+{'name': '_ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
+{'name': '_ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
+{'name': '_ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
+{'name': '_ZTSNSt3__116__narrow_to_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__116__narrow_to_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__117__assoc_sub_stateE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
+{'name': '_ZTSNSt3__117__widen_from_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__117__widen_from_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__118__time_get_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTSNSt3__118__time_get_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTSNSt3__119__shared_weak_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 30}
+{'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__120__codecvt_utf8_utf16IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__120__time_get_c_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__120__time_get_c_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__124__libcpp_debug_exceptionE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__15ctypeIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
+{'name': '_ZTSNSt3__15ctypeIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
+{'name': '_ZTSNSt3__16locale5facetE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
+{'name': '_ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
+{'name': '_ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
+{'name': '_ZTSNSt3__17collateIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 20}
+{'name': '_ZTSNSt3__17collateIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 20}
+{'name': '_ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
+{'name': '_ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
+{'name': '_ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
+{'name': '_ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
+{'name': '_ZTSNSt3__18__c_nodeE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
+{'name': '_ZTSNSt3__18ios_base7failureE', 'is_defined': True, 'type': 'OBJECT', 'size': 26}
+{'name': '_ZTSNSt3__18ios_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
+{'name': '_ZTSNSt3__18messagesIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__18messagesIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__18numpunctIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__18numpunctIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
+{'name': '_ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
+{'name': '_ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
+{'name': '_ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
+{'name': '_ZTSNSt3__19__num_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
+{'name': '_ZTSNSt3__19__num_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
+{'name': '_ZTSNSt3__19__num_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
+{'name': '_ZTSNSt3__19__num_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
+{'name': '_ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
+{'name': '_ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
+{'name': '_ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
+{'name': '_ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
+{'name': '_ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
+{'name': '_ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
+{'name': '_ZTSNSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 19}
+{'name': '_ZTSNSt3__19time_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 19}
+{'name': '_ZTSSt12bad_any_cast', 'is_defined': True, 'type': 'OBJECT', 'size': 17}
+{'name': '_ZTSSt16nested_exception', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
+{'name': '_ZTSSt18bad_variant_access', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
+{'name': '_ZTSSt19bad_optional_access', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
+{'name': '_ZTTNSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTTNSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
+{'name': '_ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTTNSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVN10__cxxabiv117__class_type_infoE', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVN10__cxxabiv120__si_class_type_infoE', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVN10__cxxabiv121__vmi_class_type_infoE', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt12experimental19bad_optional_accessE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__110moneypunctIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__110moneypunctIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__110moneypunctIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__110moneypunctIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__111regex_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__112bad_weak_ptrE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__112ctype_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
+{'name': '_ZTVNSt3__112ctype_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 136}
+{'name': '_ZTVNSt3__112future_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__112strstreambufE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
+{'name': '_ZTVNSt3__112system_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__114__codecvt_utf8IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__114__codecvt_utf8IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__114__codecvt_utf8IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__114__shared_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 120}
+{'name': '_ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__114collate_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__114collate_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__114error_categoryE', 'is_defined': True, 'type': 'OBJECT', 'size': 72}
+{'name': '_ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
+{'name': '_ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
+{'name': '_ZTVNSt3__115messages_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__115messages_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__115numpunct_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__115numpunct_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 224}
+{'name': '_ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 224}
+{'name': '_ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
+{'name': '_ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
+{'name': '_ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__117__assoc_sub_stateE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
+{'name': '_ZTVNSt3__117__widen_from_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__117__widen_from_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
+{'name': '_ZTVNSt3__119__shared_weak_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__124__libcpp_debug_exceptionE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__15ctypeIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
+{'name': '_ZTVNSt3__15ctypeIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 136}
+{'name': '_ZTVNSt3__16locale5facetE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
+{'name': '_ZTVNSt3__17collateIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__17collateIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
+{'name': '_ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
+{'name': '_ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
+{'name': '_ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
+{'name': '_ZTVNSt3__18__c_nodeE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__18ios_base7failureE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVNSt3__18ios_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTVNSt3__18messagesIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__18messagesIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
+{'name': '_ZTVNSt3__18numpunctIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__18numpunctIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
+{'name': '_ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
+{'name': '_ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
+{'name': '_ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
+{'name': '_ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
+{'name': '_ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
+{'name': '_ZTVNSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 120}
+{'name': '_ZTVSt11logic_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVSt12bad_any_cast', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVSt12length_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVSt12out_of_range', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVSt13runtime_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVSt14overflow_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVSt16invalid_argument', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
+{'name': '_ZTVSt16nested_exception', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
+{'name': '_ZTVSt18bad_variant_access', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZTVSt19bad_optional_access', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
+{'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZThn16_NSt3__19strstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZThn16_NSt3__19strstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__110istrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__110istrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__110ostrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__110ostrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__19strstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZTv0_n24_NSt3__19strstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdaPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdaPvRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdaPvSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdaPvSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdaPvm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdaPvmSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdlPv', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdlPvRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdlPvSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdlPvSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdlPvm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZdlPvmSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_Znam', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZnamRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZnamSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZnamSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_Znwm', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZnwmRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZnwmSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '_ZnwmSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
+{'name': '__cxa_allocate_exception', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_begin_catch', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_current_primary_exception', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_decrement_exception_refcount', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_end_catch', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_free_exception', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_guard_abort', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_guard_acquire', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_guard_release', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_increment_exception_refcount', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_pure_virtual', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_rethrow', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_rethrow_primary_exception', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_throw', 'is_defined': False, 'type': 'FUNC'}
+{'name': '__cxa_uncaught_exceptions', 'is_defined': False, 'type': 'FUNC'}
-- 
GitLab


From 25c089ef5d6c3bca7f23460d5dad6503f3ae5213 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 10 Feb 2019 04:41:48 +0000
Subject: [PATCH 125/137] Add missing symbols to Apple v2 abi list.

The itoa symbols were added and their addition is documented in the CHANGELOG.
I'm not sure why the valarray symbols were missing previously, but they're
present in the v1 ABI lists and should be here as well.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353633 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/abi/x86_64-apple-darwin.v2.abilist | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/lib/abi/x86_64-apple-darwin.v2.abilist b/lib/abi/x86_64-apple-darwin.v2.abilist
index 5880a3bfd..2659dd261 100644
--- a/lib/abi/x86_64-apple-darwin.v2.abilist
+++ b/lib/abi/x86_64-apple-darwin.v2.abilist
@@ -1190,6 +1190,8 @@
 {'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wcerrE', 'size': 0}
 {'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wclogE', 'size': 0}
 {'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wcoutE', 'size': 0}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__itoa8__u32toaEjPc'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__itoa8__u64toaEyPc'}
 {'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_'}
 {'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIccEEPcEEvT0_S5_T_'}
 {'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIddEEPdEEvT0_S5_T_'}
@@ -1388,6 +1390,10 @@
 {'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
 {'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
 {'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImE6resizeEmm'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImEC1Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImEC2Em'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImED1Ev'}
+{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImED2Ev'}
 {'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_PKc'}
 {'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_prepERNS_8ios_baseERc'}
 {'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_'}
-- 
GitLab


From b9a4d073afbf50955bf04eef6060362cf0c8e964 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 10 Feb 2019 04:48:54 +0000
Subject: [PATCH 126/137]  Format sym_extract.py output to minimize diff
 output.

 Different versions of python print dictionaries in different orders.
 This can mess up diffs when updating ABI lists. This patch uses
 pprint.pformat to print the dicts to get a consistent ordering.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353634 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/abi/x86_64-apple-darwin.v1.abilist      | 4720 +++++++++----------
 lib/abi/x86_64-apple-darwin.v2.abilist      | 4642 +++++++++---------
 lib/abi/x86_64-unknown-linux-gnu.v1.abilist | 3722 +++++++--------
 utils/libcxx/sym_check/util.py              |    4 +-
 4 files changed, 6545 insertions(+), 6543 deletions(-)

diff --git a/lib/abi/x86_64-apple-darwin.v1.abilist b/lib/abi/x86_64-apple-darwin.v1.abilist
index 65a034961..6349acf05 100644
--- a/lib/abi/x86_64-apple-darwin.v1.abilist
+++ b/lib/abi/x86_64-apple-darwin.v1.abilist
@@ -1,2360 +1,2360 @@
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt10bad_typeid4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt10bad_typeid4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt11logic_error4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt11logic_error4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12bad_any_cast4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13bad_exception4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13bad_exception4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13runtime_error4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13runtime_error4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt16nested_exception14rethrow_nestedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt18bad_variant_access4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt19bad_optional_access4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110error_code7messageEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__decrementableEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__find_c_from_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__subscriptableEPKvl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__dereferenceableEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__find_c_and_lockEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db8__find_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db9__addableEPKvl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112bad_weak_ptr4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_scan_isEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE11do_scan_notEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEjw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEwc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112strstreambuf6pcountEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__113random_device7entropyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentERKNS_10error_codeEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category23default_error_conditionEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115error_condition7messageEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIcE15__do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIwE15__do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__XEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__cEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__rEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__xEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__am_pmEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__weeksEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE8__monthsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__XEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__cEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__rEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__xEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__am_pmEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__weeksEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE8__monthsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__124__libcpp_debug_exception4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_scan_isEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE11do_scan_notEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEPKwS3_Pj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEjw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEwc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale4nameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale9has_facetERNS0_2idE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale9use_facetERNS0_2idE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16localeeqERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE12do_transformEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE7do_hashEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE12do_transformEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE7do_hashEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18ios_base6getlocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE8do_closeEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE8do_closeEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_truenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE12do_falsenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_truenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE12do_falsenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt8bad_cast4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt8bad_cast4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9bad_alloc4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9bad_alloc4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9exception4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9exception4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_erroraSERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC2ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptraSERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_erroraSERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110adopt_lockE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5alnumE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5alphaE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5blankE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5cntrlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5digitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5graphE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5lowerE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5printE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5punctE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5spaceE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5upperE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base6xdigitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110defer_lockE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE4intlE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__call_onceERVmPvPFvS2_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db11__insert_icEPvPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db15__iterator_copyEPvPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db16__invalidate_allEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db4swapEPvS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__111try_to_lockE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__do_nothingEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__get_sp_mutEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__next_primeEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112__rs_default4__c_E', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultclEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorC1ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorC2ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_1E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_2E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_3E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_4E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_5E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_6E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_7E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_8E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_9E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders3_10E', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf3strEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf4swapERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf6__initEPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf6freezeEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPFPvmEPFvS1_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKal'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKhl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPalS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPhlS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1El'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPFPvmEPFvS1_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKal'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKhl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPalS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPhlS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2El'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__113allocator_argE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreEli'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceclEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvEaSERKS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__get_const_dbEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__114__num_get_base5__srcE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base12__format_intEPcPKcbj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base14__format_floatEPcPKcj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_count12__add_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_count16__release_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__get_classnameEPKcb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115future_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcE6__initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwE6__initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115system_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116generic_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state12__make_readyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state16__on_zero_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4copyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4waitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9__executeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9set_valueEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117declare_reachableEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117iostream_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_allEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_oneEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variableD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variableD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118get_pointer_safetyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex11lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex13unlock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex15try_lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base11lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base13unlock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base15try_lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count10__add_weakEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count12__add_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count14__release_weakEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count16__release_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__thread_local_dataEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119declare_no_pointersEPcm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__119piecewise_constructE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__120__get_collation_nameEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__120__throw_system_errorEiPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121__throw_runtime_errorEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121__undeclare_reachableEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121undeclare_no_pointersEPcm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__123__libcpp_debug_functionE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__13cinE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14cerrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14clogE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14coutE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14wcinE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15alignEmmRPvRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcE13classic_tableEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC1EPKjbm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC2EPKjbm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wcerrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wclogE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wcoutE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__itoa8__u32toaEjPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__itoa8__u64toaEyPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock3nowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock9is_steadyE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock11from_time_tEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock3nowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9is_steadyE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16gslice6__initEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale2id5__getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale2id6__initEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale2id9__next_idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale3allE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale4noneE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale4timeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale5ctypeE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facet16__on_zero_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale6globalERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale7classicEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale7collateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale7numericE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale8__globalEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale8messagesE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale8monetaryE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_PKci'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_S2_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_PKci'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_S2_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeaSERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread20hardware_concurrencyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread4joinEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread6detachEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16threadD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16threadD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17collateIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17collateIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE10get_futureEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE24set_value_at_thread_exitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE9set_valueEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_node5__addEPNS_8__i_nodeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__get_dbEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__i_nodeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__i_nodeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__rs_getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__sp_mut4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__sp_mut6unlockEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base10floatfieldE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base10scientificE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base11adjustfieldE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base15sync_with_stdioEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base16__call_callbacksENS0_5eventE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base2inE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3appE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3ateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3decE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3hexE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3octE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3outE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4initEPv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base4leftE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4moveERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4swapERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5clearEj'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5fixedE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5iwordEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5pwordEi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5rightE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5truncE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6badbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6binaryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6eofbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6skipwsE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base6xallocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7copyfmtERKS0_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failbitE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7goodbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7showposE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7unitbufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base8internalE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base8showbaseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9__xindex_E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9basefieldE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9boolalphaE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9showpointE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9uppercaseE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18messagesIcE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18messagesIwE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImE6resizeEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt10unexpectedv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt10unexpectedv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt13get_terminatev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt13get_terminatev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt13set_terminatePFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt13set_terminatePFvvE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt14get_unexpectedv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt14get_unexpectedv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt14set_unexpectedPFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt14set_unexpectedPFvvE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt15get_new_handlerv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt15get_new_handlerv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt15set_new_handlerPFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt15set_new_handlerPFvvE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17__throw_bad_allocv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17current_exceptionv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17rethrow_exceptionSt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt18uncaught_exceptionv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt19uncaught_exceptionsv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZSt7nothrow', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt9terminatev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt9terminatev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDs'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110__time_getE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110__time_putE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110ctype_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110money_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112codecvt_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113messages_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__num_get_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__num_put_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__shared_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__assoc_sub_stateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__119__shared_weak_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__124__libcpp_debug_exceptionE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__15ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__15ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__16locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19strstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19time_baseE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9type_info'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTId'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTId'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110ctype_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110money_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__111regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112codecvt_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113messages_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__15ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__15ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__16locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19strstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19time_baseE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9type_info'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSy'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__19strstreamE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__111regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__shared_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__assoc_sub_stateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__119__shared_weak_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__124__libcpp_debug_exceptionE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__15ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__15ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__16locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19strstreamE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9type_info'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__Znam'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__Znwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_tRKSt9nothrow_t'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_allocate_exception'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_allocate_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_atexit'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_begin_catch'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_begin_catch'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_call_unexpected'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_call_unexpected'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_current_exception_type'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_current_exception_type'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_current_primary_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_decrement_exception_refcount'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_deleted_virtual'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_deleted_virtual'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_demangle'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_demangle'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_end_catch'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_end_catch'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_free_exception'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_free_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_exception_ptr'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_exception_ptr'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals_fast'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals_fast'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_abort'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_abort'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_acquire'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_acquire'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_release'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_release'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_increment_exception_refcount'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_pure_virtual'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_pure_virtual'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_rethrow'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow_primary_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_throw'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_throw'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_uncaught_exceptions'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cctor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cctor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cleanup'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cleanup'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_ctor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_ctor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete2'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete2'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete3'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete3'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_dtor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_dtor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new2'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new2'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new3'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new3'}
-{'type': 'U', 'is_defined': False, 'name': '___dynamic_cast'}
-{'type': 'I', 'is_defined': True, 'name': '___dynamic_cast'}
-{'type': 'U', 'is_defined': False, 'name': '___gxx_personality_v0'}
-{'type': 'I', 'is_defined': True, 'name': '___gxx_personality_v0'}
+{'is_defined': False, 'name': '__ZNKSt10bad_typeid4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt10bad_typeid4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt11logic_error4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt11logic_error4whatEv', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNKSt12bad_any_cast4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNKSt13bad_exception4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt13bad_exception4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt13runtime_error4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt13runtime_error4whatEv', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNKSt16nested_exception14rethrow_nestedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt18bad_variant_access4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt19bad_optional_access4whatEv', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNKSt20bad_array_new_length4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt20bad_array_new_length4whatEv', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110error_code7messageEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__decrementableEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__find_c_from_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__subscriptableEPKvl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__dereferenceableEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__find_c_and_lockEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db8__find_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db9__addableEPKvl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112bad_weak_ptr4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_scan_isEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE11do_scan_notEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEjw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEwc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__112strstreambuf6pcountEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__113random_device7entropyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentERKNS_10error_codeEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__114error_category23default_error_conditionEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__115error_condition7messageEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIcE15__do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIwE15__do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__XEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__cEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__rEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__xEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__am_pmEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__weeksEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE8__monthsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__XEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__cEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__rEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__xEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__am_pmEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__weeksEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE8__monthsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__124__libcpp_debug_exception4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_scan_isEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE11do_scan_notEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEPKwS3_Pj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEjw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEwc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__16locale4nameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__16locale9has_facetERNS0_2idE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__16locale9use_facetERNS0_2idE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__16localeeqERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17collateIcE12do_transformEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17collateIcE7do_hashEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17collateIwE12do_transformEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17collateIwE7do_hashEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18ios_base6getlocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18messagesIcE8do_closeEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18messagesIwE8do_closeEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_truenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE12do_falsenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_truenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE12do_falsenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNKSt8bad_cast4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt8bad_cast4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt9bad_alloc4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt9bad_alloc4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt9exception4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt9exception4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt11logic_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11logic_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11logic_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt11logic_erroraSERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt11range_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11range_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11range_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11range_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11range_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11range_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12domain_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12domain_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12domain_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12domain_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12domain_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12domain_errorD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD2Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt12length_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12length_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12length_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12length_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12length_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12length_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12out_of_rangeD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12out_of_rangeD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12out_of_rangeD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12out_of_rangeD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12out_of_rangeD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12out_of_rangeD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13bad_exceptionD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13bad_exceptionD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13bad_exceptionD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13bad_exceptionD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13bad_exceptionD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13bad_exceptionD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrC2ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptraSERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt13runtime_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13runtime_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13runtime_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt13runtime_erroraSERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt14overflow_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt14overflow_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt14overflow_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt14overflow_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt14overflow_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt14overflow_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt15underflow_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt15underflow_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt15underflow_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt15underflow_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt15underflow_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt15underflow_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt16invalid_argumentD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt16invalid_argumentD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt16invalid_argumentD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt16invalid_argumentD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt16invalid_argumentD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt16invalid_argumentD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt19bad_optional_accessD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt19bad_optional_accessD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt19bad_optional_accessD2Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_getC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_getC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_getD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_getD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_putC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_putC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_putD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110__time_putD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110adopt_lockE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5alnumE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5alphaE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5blankE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5cntrlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5digitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5graphE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5lowerE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5printE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5punctE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5spaceE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base5upperE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ctype_base6xdigitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110defer_lockE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110istrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110istrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110istrstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__110ostrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110ostrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110ostrstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__110to_wstringEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__call_onceERVmPvPFvS2_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db11__insert_icEPvPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db15__iterator_copyEPvPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db16__invalidate_allEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db4swapEPvS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111regex_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111regex_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111regex_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111timed_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111timed_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__111try_to_lockE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112__do_nothingEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__get_sp_mutEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__next_primeEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_default4__c_E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112__rs_defaultclEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112future_errorC1ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112future_errorC2ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112future_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112future_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112future_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_1E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_2E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_3E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_4E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_5E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_6E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_7E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_8E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders2_9E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112placeholders3_10E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf3strEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf4swapERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf6__initEPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf6freezeEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambuf9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPFPvmEPFvS1_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKal', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKhl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPalS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPhlS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC1El', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPFPvmEPFvS1_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKal', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKhl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPalS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPhlS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufC2El', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112strstreambufD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__112system_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113allocator_argE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreEli', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113random_deviceD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113random_deviceD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113random_deviceclEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__113shared_futureIvEaSERKS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__get_const_dbEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__num_get_base5__srcE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__114__num_put_base12__format_intEPcPKcbj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__num_put_base14__format_floatEPcPKcj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__shared_count12__add_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__shared_count16__release_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__shared_countD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__shared_countD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114__shared_countD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114error_categoryC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114error_categoryD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114error_categoryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__114error_categoryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115__get_classnameEPKcb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115__thread_structC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115__thread_structC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115__thread_structD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115__thread_structD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115future_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcE6__initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwE6__initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115recursive_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115recursive_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115recursive_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__115system_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__116generic_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state12__make_readyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state16__on_zero_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4copyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4waitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9__executeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9set_valueEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117declare_reachableEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117iostream_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_allEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_oneEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118condition_variableD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118condition_variableD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118get_pointer_safetyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex11lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex13unlock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex15try_lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base11lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base13unlock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base15try_lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count10__add_weakEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count12__add_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count14__release_weakEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count16__release_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119__thread_local_dataEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119declare_no_pointersEPcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__119piecewise_constructE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__120__get_collation_nameEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__120__throw_system_errorEiPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121__throw_runtime_errorEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121__undeclare_reachableEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__121undeclare_no_pointersEPcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__123__libcpp_debug_functionE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__13cinE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__14cerrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__14clogE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__14coutE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__14wcinE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__15alignEmmRPvRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIcE13classic_tableEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC1EPKjbm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC2EPKjbm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15ctypeIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__15wcerrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__15wclogE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__15wcoutE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16__itoa8__u32toaEjPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__itoa8__u64toaEyPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock3nowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock9is_steadyE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock11from_time_tEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock3nowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9is_steadyE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16futureIvE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16futureIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16futureIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16gslice6__initEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale2id5__getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale2id6__initEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale2id9__next_idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale3allE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale4noneE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale4timeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale5ctypeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale5facet16__on_zero_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale5facetD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale5facetD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale5facetD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale6globalERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale7classicEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale7collateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale7numericE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale8__globalEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16locale8messagesE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16locale8monetaryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_PKci', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_S2_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_PKci', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_S2_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16localeaSERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16thread20hardware_concurrencyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16thread4joinEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16thread6detachEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16threadD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__16threadD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17collateIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvE10get_futureEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvE24set_value_at_thread_exitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvE9set_valueEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__17promiseIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__c_node5__addEPNS_8__i_nodeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__c_nodeD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__c_nodeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__c_nodeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__get_dbEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__i_nodeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__i_nodeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__rs_getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__sp_mut4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18__sp_mut6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base10floatfieldE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base10scientificE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base11adjustfieldE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base15sync_with_stdioEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base16__call_callbacksENS0_5eventE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base2inE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base3appE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base3ateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base3decE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base3hexE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base3octE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base3outE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4initEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4leftE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4moveERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base4swapERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base5clearEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base5fixedE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base5iwordEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base5pwordEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base5rightE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base5truncE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base6badbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base6binaryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base6eofbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base6skipwsE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base6xallocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7copyfmtERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7goodbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7showposE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base7unitbufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base8internalE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base8showbaseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base9__xindex_E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base9basefieldE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base9boolalphaE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base9showpointE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_base9uppercaseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_baseD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_baseD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18ios_baseD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18messagesIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18messagesIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18numpunctIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__18valarrayImE6resizeEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18valarrayImEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18valarrayImEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18valarrayImED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__18valarrayImED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__19strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19strstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__19to_stringEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt8bad_castC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9exceptionD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9exceptionD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9exceptionD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9exceptionD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9exceptionD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9exceptionD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9type_infoD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9type_infoD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9type_infoD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9type_infoD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9type_infoD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9type_infoD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt10unexpectedv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt10unexpectedv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt13get_terminatev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt13get_terminatev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt13set_terminatePFvvE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt13set_terminatePFvvE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt14get_unexpectedv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt14get_unexpectedv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt14set_unexpectedPFvvE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt14set_unexpectedPFvvE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt15get_new_handlerv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt15get_new_handlerv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt15set_new_handlerPFvvE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt15set_new_handlerPFvvE', 'type': 'I'}
+{'is_defined': True, 'name': '__ZSt17__throw_bad_allocv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt17current_exceptionv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt17rethrow_exceptionSt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt18uncaught_exceptionv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt19uncaught_exceptionsv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt7nothrow', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZSt9terminatev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt9terminatev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTIDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIDs', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt12experimental19bad_optional_accessE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110__time_getE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110__time_putE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110ctype_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110money_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__110ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__111__money_getIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__111__money_getIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__111__money_putIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__111__money_putIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__111regex_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__112bad_weak_ptrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__112codecvt_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__112future_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__112strstreambufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__112system_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__113messages_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114__num_get_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114__num_put_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114__shared_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__114error_categoryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__117__assoc_sub_stateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__119__shared_weak_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__124__libcpp_debug_exceptionE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__15ctypeIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__15ctypeIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__16locale5facetE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17codecvtIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17codecvtIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17codecvtIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17collateIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17collateIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18__c_nodeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18ios_base7failureE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18ios_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18messagesIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18messagesIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18numpunctIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18numpunctIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19__num_getIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19__num_getIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19__num_putIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19__num_putIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__19time_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTIPDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt10bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt10bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt11logic_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt11logic_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt11range_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt11range_error', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTISt12bad_any_cast', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTISt12domain_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt12domain_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt12length_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt12length_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt12out_of_range', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt12out_of_range', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt13bad_exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt13bad_exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt13runtime_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt13runtime_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt14overflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt14overflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt15underflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt15underflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt16invalid_argument', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt16invalid_argument', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTISt16nested_exception', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTISt18bad_variant_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTISt19bad_optional_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTISt20bad_array_new_length', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt20bad_array_new_length', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt8bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt8bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt9bad_alloc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt9bad_alloc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt9exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt9exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt9type_info', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt9type_info', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTId', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTId', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv117__array_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv117__array_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv117__class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv117__class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv120__function_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv120__function_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt12experimental19bad_optional_accessE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110ctype_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110money_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__110ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__111regex_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__112bad_weak_ptrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__112codecvt_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__112future_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__112strstreambufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__112system_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__113messages_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__114error_categoryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__15ctypeIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__15ctypeIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__16locale5facetE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17collateIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17collateIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18__c_nodeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18ios_base7failureE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18ios_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18messagesIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18messagesIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18numpunctIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18numpunctIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19__num_getIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19__num_getIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19__num_putIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19__num_putIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__19time_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTSPDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt10bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt10bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt11logic_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt11logic_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt11range_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt11range_error', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTSSt12bad_any_cast', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTSSt12domain_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt12domain_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt12length_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt12length_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt12out_of_range', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt12out_of_range', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt13bad_exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt13bad_exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt13runtime_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt13runtime_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt14overflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt14overflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt15underflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt15underflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt16invalid_argument', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt16invalid_argument', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTSSt16nested_exception', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSSt18bad_variant_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSSt19bad_optional_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTSSt20bad_array_new_length', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt20bad_array_new_length', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt8bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt8bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt9bad_alloc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt9bad_alloc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt9exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt9exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt9type_info', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt9type_info', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSy', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTTNSt3__110istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__110ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__19strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv117__array_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv117__array_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv117__class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv117__class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv120__function_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv120__function_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt12experimental19bad_optional_accessE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__110istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__110ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__111regex_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__112bad_weak_ptrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__112future_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__112strstreambufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__112system_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114__shared_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__114error_categoryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__117__assoc_sub_stateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__119__shared_weak_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__124__libcpp_debug_exceptionE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__15ctypeIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__15ctypeIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__16locale5facetE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17collateIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17collateIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18__c_nodeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18ios_base7failureE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18ios_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18messagesIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18messagesIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18numpunctIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18numpunctIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__19strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVSt10bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt10bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt11logic_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt11logic_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt11range_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt11range_error', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTVSt12bad_any_cast', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVSt12domain_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt12domain_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt12length_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt12length_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt12out_of_range', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt12out_of_range', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt13bad_exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt13bad_exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt13runtime_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt13runtime_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt14overflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt14overflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt15underflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt15underflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt16invalid_argument', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt16invalid_argument', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTVSt16nested_exception', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVSt18bad_variant_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVSt19bad_optional_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVSt20bad_array_new_length', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt20bad_array_new_length', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt8bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt8bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt9bad_alloc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt9bad_alloc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt9exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt9exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt9type_info', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt9type_info', 'type': 'I'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__Znam', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnamRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnamSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnamSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__Znwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnwmRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnwmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnwmSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': False, 'name': '___cxa_allocate_exception', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_allocate_exception', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_atexit', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_begin_catch', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_begin_catch', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_call_unexpected', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_call_unexpected', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_current_exception_type', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_current_exception_type', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_current_primary_exception', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_decrement_exception_refcount', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_deleted_virtual', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_deleted_virtual', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_demangle', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_demangle', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_end_catch', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_end_catch', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_free_exception', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_free_exception', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_get_exception_ptr', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_get_exception_ptr', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_get_globals', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_get_globals', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_get_globals_fast', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_get_globals_fast', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_guard_abort', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_guard_abort', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_guard_acquire', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_guard_acquire', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_guard_release', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_guard_release', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_increment_exception_refcount', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_pure_virtual', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_pure_virtual', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_rethrow', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_rethrow', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_rethrow_primary_exception', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_throw', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_throw', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_uncaught_exceptions', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_vec_cctor', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_cctor', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_cleanup', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_cleanup', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_ctor', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_ctor', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_delete', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_delete', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_delete2', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_delete2', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_delete3', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_delete3', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_dtor', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_dtor', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_new', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_new', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_new2', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_new2', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_new3', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_new3', 'type': 'I'}
+{'is_defined': False, 'name': '___dynamic_cast', 'type': 'U'}
+{'is_defined': True, 'name': '___dynamic_cast', 'type': 'I'}
+{'is_defined': False, 'name': '___gxx_personality_v0', 'type': 'U'}
+{'is_defined': True, 'name': '___gxx_personality_v0', 'type': 'I'}
diff --git a/lib/abi/x86_64-apple-darwin.v2.abilist b/lib/abi/x86_64-apple-darwin.v2.abilist
index 2659dd261..adabbf6e0 100644
--- a/lib/abi/x86_64-apple-darwin.v2.abilist
+++ b/lib/abi/x86_64-apple-darwin.v2.abilist
@@ -1,2321 +1,2321 @@
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt10bad_typeid4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt10bad_typeid4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt11logic_error4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt11logic_error4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12bad_any_cast4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13bad_exception4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13bad_exception4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13runtime_error4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13runtime_error4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt16nested_exception14rethrow_nestedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt18bad_variant_access4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt19bad_optional_access4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210__time_put8__do_putEPcRS1_PK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210__time_put8__do_putEPwRS1_PK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210error_code7messageEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__decrementableEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__find_c_from_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__subscriptableEPKvl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db17__dereferenceableEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db17__find_c_and_lockEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db22__less_than_comparableEPKvS2_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db8__find_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db9__addableEPKvl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212bad_weak_ptr4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_tolowerEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_tolowerEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_toupperEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_toupperEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_scan_isEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_tolowerEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_tolowerEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_toupperEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_toupperEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE11do_scan_notEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE5do_isEPKwS3_Pj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE5do_isEjw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE8do_widenEPKcS3_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE9do_narrowEPKwS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE9do_narrowEwc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__212strstreambuf6pcountEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__213random_device7entropyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIcE10do_compareEPKcS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIcE12do_transformEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIwE10do_compareEPKwS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIwE12do_transformEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214error_category10equivalentERKNS_10error_codeEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214error_category10equivalentEiRKNS_15error_conditionE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__214error_category23default_error_conditionEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__215error_condition7messageEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217bad_function_call4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__218__time_get_storageIcE15__do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__218__time_get_storageIwE15__do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__219__shared_weak_count13__get_deleterERKSt9type_info'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__XEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__cEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__rEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__xEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE7__am_pmEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE7__weeksEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE8__monthsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__XEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__cEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__rEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__xEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE7__am_pmEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE7__weeksEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE8__monthsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__vector_base_commonILb1EE20__throw_length_errorEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__220__vector_base_commonILb1EE20__throw_out_of_rangeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__221__basic_string_commonILb1EE20__throw_length_errorEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__221__basic_string_commonILb1EE20__throw_out_of_rangeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__223__match_any_but_newlineIcE6__execERNS_7__stateIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__223__match_any_but_newlineIwE6__execERNS_7__stateIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__224__libcpp_debug_exception4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_tolowerEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_tolowerEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_toupperEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_toupperEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE8do_widenEPKcS3_Pc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE9do_narrowEPKcS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE9do_narrowEcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_scan_isEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_tolowerEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_tolowerEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_toupperEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_toupperEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE11do_scan_notEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE5do_isEPKwS3_Pj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE5do_isEjw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE8do_widenEPKcS3_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE9do_narrowEPKwS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE9do_narrowEwc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26locale4nameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26locale9has_facetERNS0_2idE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26locale9use_facetERNS0_2idE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__26localeeqERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIcE10do_compareEPKcS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIcE12do_transformEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIcE7do_hashEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIwE10do_compareEPKwS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIwE12do_transformEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27collateIwE7do_hashEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28ios_base6getlocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIcE8do_closeEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28messagesIwE8do_closeEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE11do_truenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE12do_falsenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE11do_truenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE12do_falsenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIcE10__do_widenERNS_8ios_baseEPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIcE12__do_widen_pERNS_8ios_baseEPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIwE10__do_widenERNS_8ios_baseEPw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29__num_getIwE12__do_widen_pERNS_8ios_baseEPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt8bad_cast4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt8bad_cast4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9bad_alloc4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9bad_alloc4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9exception4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9exception4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_erroraSERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC2ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptraSERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_erroraSERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_getD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210__time_putD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210adopt_lockE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5alnumE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5alphaE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5blankE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5cntrlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5digitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5graphE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5lowerE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5printE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5punctE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5spaceE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base5upperE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210ctype_base6xdigitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210defer_lockE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210istrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210istrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210istrstreamD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb0EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb0EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb1EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb1EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb0EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb0EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb1EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb1EE4intlE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210ostrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210ostrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210ostrstreamD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__210to_wstringEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__call_onceERVmPvPFvS2_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db10__insert_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db10__insert_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db11__insert_icEPvPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db15__iterator_copyEPvPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db16__invalidate_allEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db4swapEPvS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db9__erase_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_db9__erase_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorC1ENS_15regex_constants10error_typeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorC2ENS_15regex_constants10error_typeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211regex_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__211timed_mutexD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__211try_to_lockE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__do_nothingEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__get_sp_mutEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__next_primeEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212__rs_default4__c_E', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212__rs_defaultclEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorC1ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorC2ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212future_errorD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_1E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_2E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_3E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_4E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_5E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_6E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_7E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_8E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders2_9E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__212placeholders3_10E', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf3strEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf4swapERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf6__initEPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf6freezeEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambuf9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPFPvmEPFvS1_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKal'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKhl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPalS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPhlS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC1El'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPFPvmEPFvS1_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKal'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKhl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPalS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPhlS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufC2El'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212strstreambufD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__212system_errorD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__213allocator_argE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getEPclc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4peekEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4readEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5tellgEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5ungetEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6ignoreEli'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE7putbackEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getEPwlw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4peekEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4readEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5tellgEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5ungetEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6ignoreEli'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE7putbackEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE3putEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE5flushEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE3putEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE5flushEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213random_deviceclEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213shared_futureIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213shared_futureIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__213shared_futureIvEaSERKS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__get_const_dbEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_get_base10__get_baseERNS_8ios_baseE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__214__num_get_base5__srcE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_put_base12__format_intEPcPKcbj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_put_base14__format_floatEPcPKcj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__shared_countD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__shared_countD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214__shared_countD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214error_categoryD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214error_categoryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__214error_categoryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__get_classnameEPKcb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215__thread_structD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE5uflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9showmanycEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEaSERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE5uflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9showmanycEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEaSERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215future_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcE6__initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwE6__initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215recursive_mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__215system_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__216generic_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state12__make_readyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state13set_exceptionESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state16__on_zero_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state24set_value_at_thread_exitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state4copyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state4waitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state9__executeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state9set_valueEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217bad_function_callD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217bad_function_callD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217bad_function_callD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217declare_reachableEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217iostream_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIcLb0EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIcLb1EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIwLb0EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIwLb1EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcE4initERKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwE4initERKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable10notify_allEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable10notify_oneEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variable4waitERNS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variableD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218condition_variableD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex11lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex13unlock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex15try_lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base11lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base13unlock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base15try_lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_baseC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_baseC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_count14__release_weakEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_count4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219__thread_local_dataEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__219declare_no_pointersEPcm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__219piecewise_constructE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__220__get_collation_nameEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__220__throw_system_errorEiPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221__throw_runtime_errorEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221__undeclare_reachableEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__221undeclare_no_pointersEPcm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__223__libcpp_debug_functionE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__225notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__227__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__229__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__229__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__23cinE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24cerrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24clogE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24coutE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__24stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__24wcinE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25alignEmmRPvRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcE13classic_tableEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcEC1EPKjbm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcEC2EPKjbm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25ctypeIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__25stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wcerrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wclogE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__25wcoutE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__itoa8__u32toaEjPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__itoa8__u64toaEyPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIccEEPcEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIddEEPdEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIffEEPfEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIllEEPlEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessImmEEPmEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIssEEPsEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIttEEPtEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12steady_clock3nowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26chrono12steady_clock9is_steadyE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock11from_time_tEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock3nowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock9is_steadyE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvEC1EPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvEC2EPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26futureIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26gslice6__initEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale14__install_ctorERKS0_PNS0_5facetEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale2id5__getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale2id6__initEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale2id9__next_idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale3allE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale4noneE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale4timeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale5ctypeE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facet16__on_zero_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facetD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facetD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale5facetD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale6globalERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale7classicEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale7collateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale7numericE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26locale8__globalEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale8messagesE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__26locale8monetaryE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_PKci'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_S2_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_PKci'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_S2_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26localeaSERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26thread20hardware_concurrencyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26thread4joinEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26thread6detachEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26threadD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__26threadD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27collateIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27collateIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27collateIwED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE10get_futureEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE13set_exceptionESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE24set_value_at_thread_exitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE28set_exception_at_thread_exitESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvE9set_valueEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__27promiseIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_node5__addEPNS_8__i_nodeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_nodeD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_nodeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__c_nodeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__get_dbEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__i_nodeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__i_nodeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__rs_getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__sp_mut4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28__sp_mut6unlockEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base10floatfieldE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base10scientificE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base11adjustfieldE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base15sync_with_stdioEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base16__call_callbacksENS0_5eventE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base17register_callbackEPFvNS0_5eventERS0_iEi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base2inE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base33__set_badbit_and_consider_rethrowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base34__set_failbit_and_consider_rethrowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3appE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3ateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3decE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3hexE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3octE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base3outE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4InitD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4initEPv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base4leftE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4moveERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base4swapERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5clearEj'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base5fixedE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5iwordEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base5pwordEi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base5rightE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base5truncE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6badbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6binaryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6eofbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base6skipwsE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base6xallocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7copyfmtERKS0_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failbitE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC1EPKcRKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC2EPKcRKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7goodbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7showposE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base7unitbufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base8internalE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base8showbaseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9__xindex_E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9basefieldE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9boolalphaE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9showpointE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28ios_base9uppercaseE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_baseD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_baseD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28ios_baseD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28messagesIcE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28messagesIwE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28numpunctIwED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImE6resizeEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__28valarrayImED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_PKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_prepERNS_8ios_baseERc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_PKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE17__stage2_int_prepERNS_8ios_baseERw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29strstreamD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__29to_stringEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__2plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt10unexpectedv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt10unexpectedv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt13get_terminatev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt13get_terminatev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt13set_terminatePFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt13set_terminatePFvvE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt14get_unexpectedv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt14get_unexpectedv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt14set_unexpectedPFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt14set_unexpectedPFvvE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt15get_new_handlerv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt15get_new_handlerv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt15set_new_handlerPFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt15set_new_handlerPFvvE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17__throw_bad_allocv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17current_exceptionv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17rethrow_exceptionSt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt18uncaught_exceptionv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt19uncaught_exceptionsv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZSt7nothrow', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt9terminatev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt9terminatev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__210istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__210ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__29strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__29strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__29strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDs'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210__time_getE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210__time_putE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210ctype_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210money_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__210ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211__money_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__211regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212codecvt_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__212system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__213messages_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__num_get_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__num_put_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214__shared_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__214error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__216__narrow_to_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__216__narrow_to_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217__assoc_sub_stateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217__widen_from_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217__widen_from_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217bad_function_callE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__218__time_get_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__218__time_get_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__219__shared_weak_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__time_get_c_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__220__time_get_c_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__224__libcpp_debug_exceptionE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__25ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__25ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__26locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29__num_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29strstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__29time_baseE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9type_info'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTId'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTId'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210__time_getE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210__time_putE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210ctype_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210money_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__210ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211__money_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__211regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212codecvt_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__212system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__213messages_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__num_get_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__num_put_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214__shared_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__214error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__216__narrow_to_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__216__narrow_to_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217__assoc_sub_stateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217__widen_from_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217__widen_from_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217bad_function_callE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__218__time_get_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__218__time_get_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__219__shared_weak_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__time_get_c_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__220__time_get_c_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__224__libcpp_debug_exceptionE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__25ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__25ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__26locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29__num_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29strstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__29time_baseE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9type_info'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSy'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__210istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__210ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__29strstreamE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__210ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__211regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__212system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214__shared_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__214error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__216__narrow_to_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__216__narrow_to_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217__assoc_sub_stateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217__widen_from_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217__widen_from_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217bad_function_callE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__219__shared_weak_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__224__libcpp_debug_exceptionE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__25ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__25ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__26locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__29strstreamE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9type_info'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__29strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__29strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210istrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210istrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210ostrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__210ostrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__29strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__29strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__Znam'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__Znwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_tRKSt9nothrow_t'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_allocate_exception'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_allocate_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_atexit'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_begin_catch'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_begin_catch'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_call_unexpected'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_call_unexpected'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_current_exception_type'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_current_exception_type'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_current_primary_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_decrement_exception_refcount'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_deleted_virtual'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_deleted_virtual'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_demangle'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_demangle'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_end_catch'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_end_catch'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_free_exception'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_free_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_exception_ptr'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_exception_ptr'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals_fast'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals_fast'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_abort'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_abort'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_acquire'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_acquire'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_release'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_release'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_increment_exception_refcount'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_pure_virtual'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_pure_virtual'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_rethrow'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow_primary_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_throw'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_throw'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_uncaught_exceptions'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cctor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cctor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cleanup'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cleanup'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_ctor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_ctor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete2'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete2'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete3'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete3'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_dtor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_dtor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new2'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new2'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new3'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new3'}
-{'type': 'U', 'is_defined': False, 'name': '___dynamic_cast'}
-{'type': 'I', 'is_defined': True, 'name': '___dynamic_cast'}
-{'type': 'U', 'is_defined': False, 'name': '___gxx_personality_v0'}
-{'type': 'I', 'is_defined': True, 'name': '___gxx_personality_v0'}
+{'is_defined': False, 'name': '__ZNKSt10bad_typeid4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt10bad_typeid4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt11logic_error4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt11logic_error4whatEv', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNKSt12bad_any_cast4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNKSt13bad_exception4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt13bad_exception4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt13runtime_error4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt13runtime_error4whatEv', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNKSt16nested_exception14rethrow_nestedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt18bad_variant_access4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt19bad_optional_access4whatEv', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNKSt20bad_array_new_length4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt20bad_array_new_length4whatEv', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNKSt3__210__time_put8__do_putEPcRS1_PK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210__time_put8__do_putEPwRS1_PK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210error_code7messageEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__210moneypunctIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__decrementableEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__find_c_from_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db15__subscriptableEPKvl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db17__dereferenceableEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db17__find_c_and_lockEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db22__less_than_comparableEPKvS2_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db8__find_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__211__libcpp_db9__addableEPKvl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212bad_weak_ptr4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_tolowerEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_toupperEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIcE10do_toupperEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_scan_isEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_tolowerEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_toupperEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE10do_toupperEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE11do_scan_notEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE5do_isEPKwS3_Pj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE5do_isEjw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212ctype_bynameIwE9do_narrowEwc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__212strstreambuf6pcountEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__213random_device7entropyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIcE12do_transformEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214collate_bynameIwE12do_transformEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214error_category10equivalentERKNS_10error_codeEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214error_category10equivalentEiRKNS_15error_conditionE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__214error_category23default_error_conditionEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__215error_condition7messageEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217bad_function_call4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__217moneypunct_bynameIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__218__time_get_storageIcE15__do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__218__time_get_storageIwE15__do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__219__shared_weak_count13__get_deleterERKSt9type_info', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__XEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__cEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__rEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE3__xEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE7__am_pmEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE7__weeksEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIcE8__monthsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__XEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__cEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__rEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE3__xEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE7__am_pmEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE7__weeksEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__time_get_c_storageIwE8__monthsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__vector_base_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__220__vector_base_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__221__basic_string_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__221__basic_string_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__223__match_any_but_newlineIcE6__execERNS_7__stateIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__223__match_any_but_newlineIwE6__execERNS_7__stateIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__224__libcpp_debug_exception4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_tolowerEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_toupperEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE10do_toupperEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE8do_widenEPKcS3_Pc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE9do_narrowEPKcS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIcE9do_narrowEcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_scan_isEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_tolowerEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_toupperEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE10do_toupperEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE11do_scan_notEjPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE5do_isEPKwS3_Pj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE5do_isEjw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__25ctypeIwE9do_narrowEwc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__26locale4nameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__26locale9has_facetERNS0_2idE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__26locale9use_facetERNS0_2idE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__26localeeqERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27collateIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27collateIcE12do_transformEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27collateIcE7do_hashEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27collateIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27collateIwE12do_transformEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27collateIwE7do_hashEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28ios_base6getlocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28messagesIcE8do_closeEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28messagesIwE8do_closeEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE11do_truenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE12do_falsenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIcE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE11do_truenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE12do_falsenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28numpunctIwE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29__num_getIcE10__do_widenERNS_8ios_baseEPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29__num_getIcE12__do_widen_pERNS_8ios_baseEPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29__num_getIwE10__do_widenERNS_8ios_baseEPw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29__num_getIwE12__do_widen_pERNS_8ios_baseEPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNKSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNKSt8bad_cast4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt8bad_cast4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt9bad_alloc4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt9bad_alloc4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNKSt9exception4whatEv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNKSt9exception4whatEv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt10bad_typeidD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt10bad_typeidD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt11logic_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11logic_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11logic_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11logic_errorD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt11logic_erroraSERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt11range_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11range_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11range_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11range_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt11range_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt11range_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12domain_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12domain_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12domain_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12domain_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12domain_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12domain_errorD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD2Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt12length_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12length_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12length_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12length_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12length_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12length_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12out_of_rangeD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12out_of_rangeD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12out_of_rangeD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12out_of_rangeD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt12out_of_rangeD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt12out_of_rangeD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13bad_exceptionD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13bad_exceptionD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13bad_exceptionD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13bad_exceptionD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13bad_exceptionD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13bad_exceptionD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrC2ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptrD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13exception_ptraSERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKNSt3__212basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt13runtime_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13runtime_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt13runtime_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt13runtime_errorD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt13runtime_erroraSERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt14overflow_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt14overflow_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt14overflow_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt14overflow_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt14overflow_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt14overflow_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt15underflow_errorD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt15underflow_errorD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt15underflow_errorD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt15underflow_errorD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt15underflow_errorD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt15underflow_errorD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt16invalid_argumentD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt16invalid_argumentD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt16invalid_argumentD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt16invalid_argumentD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt16invalid_argumentD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt16invalid_argumentD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt16nested_exceptionD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt19bad_optional_accessD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt19bad_optional_accessD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt19bad_optional_accessD2Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD2Ev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_getC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_getC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_getD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_getD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_putC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_putC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_putD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210__time_putD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210adopt_lockE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5alnumE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5alphaE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5blankE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5cntrlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5digitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5graphE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5lowerE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5printE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5punctE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5spaceE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base5upperE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ctype_base6xdigitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210defer_lockE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210istrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210istrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210istrstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb0EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb0EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb1EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIcLb1EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb0EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb0EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb1EE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210moneypunctIwLb1EE4intlE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__210ostrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210ostrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210ostrstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__210to_wstringEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__call_onceERVmPvPFvS2_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db10__insert_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db10__insert_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db11__insert_icEPvPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db15__iterator_copyEPvPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db16__invalidate_allEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db4swapEPvS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db9__erase_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_db9__erase_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__libcpp_dbD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211regex_errorC1ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211regex_errorC2ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211regex_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211regex_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211regex_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211timed_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211timed_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__211try_to_lockE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212__do_nothingEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__get_sp_mutEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__next_primeEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_default4__c_E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_defaultC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_defaultD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_defaultD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212__rs_defaultclEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212bad_weak_ptrD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212ctype_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212future_errorC1ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212future_errorC2ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212future_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212future_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212future_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_1E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_2E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_3E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_4E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_5E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_6E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_7E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_8E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders2_9E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212placeholders3_10E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf3strEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf4swapERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf6__initEPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf6freezeEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambuf9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPFPvmEPFvS1_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKal', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPKhl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPalS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1EPhlS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC1El', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPFPvmEPFvS1_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKal', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPKhl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPalS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2EPhlS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufC2El', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212strstreambufD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__212system_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213allocator_argE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getEPclc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4peekEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4readEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5tellgEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE5ungetEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6ignoreEli', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE7putbackEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIcNS_11char_traitsIcEEErsERy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getEPwlw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4peekEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4readEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5tellgEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE5ungetEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6ignoreEli', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE7putbackEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_istreamIwNS_11char_traitsIwEEErsERy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE3putEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE5flushEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIcNS_11char_traitsIcEEElsEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE3putEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE5flushEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213basic_ostreamIwNS_11char_traitsIwEEElsEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213random_deviceD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213random_deviceD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213random_deviceclEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213shared_futureIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213shared_futureIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__213shared_futureIvEaSERKS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__get_const_dbEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__num_get_base10__get_baseERNS_8ios_baseE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__num_get_base5__srcE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__214__num_put_base12__format_intEPcPKcbj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__num_put_base14__format_floatEPcPKcj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__shared_countD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__shared_countD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214__shared_countD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214basic_iostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214codecvt_bynameIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214collate_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214error_categoryD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214error_categoryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__214error_categoryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215__get_classnameEPKcb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215__thread_structC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215__thread_structC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215__thread_structD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215__thread_structD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE5uflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9showmanycEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEE9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIcNS_11char_traitsIcEEEaSERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE5uflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9showmanycEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEE9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215basic_streambufIwNS_11char_traitsIwEEEaSERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215future_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcE6__initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwE6__initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215numpunct_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215recursive_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215recursive_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215recursive_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215recursive_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215recursive_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215recursive_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215recursive_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__215system_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm16EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216__narrow_to_utf8ILm32EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__216generic_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state12__make_readyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state16__on_zero_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state24set_value_at_thread_exitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state4copyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state4waitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state9__executeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__assoc_sub_state9set_valueEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm16EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217__widen_from_utf8ILm32EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217bad_function_callD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217bad_function_callD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217bad_function_callD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217declare_reachableEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217iostream_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIcLb0EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIcLb1EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIwLb0EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__217moneypunct_bynameIwLb1EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcE4initERKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwE4initERKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218condition_variable10notify_allEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218condition_variable10notify_oneEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218condition_variable4waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218condition_variableD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218condition_variableD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex11lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex13unlock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex15try_lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__218shared_timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base11lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base13unlock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base15try_lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_base8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_baseC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_mutex_baseC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_weak_count14__release_weakEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_weak_count4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__shared_weak_countD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219__thread_local_dataEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219declare_no_pointersEPcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__219piecewise_constructE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__220__get_collation_nameEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__220__throw_system_errorEiPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221__throw_runtime_errorEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221__undeclare_reachableEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221recursive_timed_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__221undeclare_no_pointersEPcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__223__libcpp_debug_functionE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__224__libcpp_debug_exceptionD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__225notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__227__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__229__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__229__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__23cinE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__24cerrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__24clogE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__24coutE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__24stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__24wcinE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__25alignEmmRPvRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIcE13classic_tableEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIcEC1EPKjbm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIcEC2EPKjbm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25ctypeIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__25wcerrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__25wclogE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__25wcoutE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26__itoa8__u32toaEjPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__itoa8__u64toaEyPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIccEEPcEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIddEEPdEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIffEEPfEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIllEEPlEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessImmEEPmEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIssEEPsEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIttEEPtEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26chrono12steady_clock3nowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26chrono12steady_clock9is_steadyE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock11from_time_tEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock3nowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock9is_steadyE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26futureIvE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26futureIvEC1EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26futureIvEC2EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26futureIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26futureIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26gslice6__initEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale14__install_ctorERKS0_PNS0_5facetEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale2id5__getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale2id6__initEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale2id9__next_idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale3allE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale4noneE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale4timeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale5ctypeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale5facet16__on_zero_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale5facetD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale5facetD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale5facetD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale6globalERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale7classicEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale7collateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale7numericE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale8__globalEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26locale8messagesE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26locale8monetaryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_PKci', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC1ERKS0_S2_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_PKci', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC2ERKS0_S2_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26localeaSERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26thread20hardware_concurrencyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26thread4joinEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26thread6detachEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26threadD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__26threadD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27codecvtIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27collateIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvE10get_futureEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvE13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvE24set_value_at_thread_exitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvE28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvE9set_valueEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__27promiseIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__c_node5__addEPNS_8__i_nodeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__c_nodeD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__c_nodeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__c_nodeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__get_dbEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__i_nodeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__i_nodeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__rs_getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__sp_mut4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28__sp_mut6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base10floatfieldE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base10scientificE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base11adjustfieldE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base15sync_with_stdioEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base16__call_callbacksENS0_5eventE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base17register_callbackEPFvNS0_5eventERS0_iEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base2inE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base33__set_badbit_and_consider_rethrowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base34__set_failbit_and_consider_rethrowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base3appE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base3ateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base3decE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base3hexE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base3octE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base3outE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4InitC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4InitC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4InitD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4InitD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4initEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4leftE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4moveERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base4swapERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base5clearEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base5fixedE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base5iwordEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base5pwordEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base5rightE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base5truncE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base6badbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base6binaryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base6eofbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base6skipwsE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base6xallocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7copyfmtERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC1EPKcRKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC2EPKcRKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7failureD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7goodbitE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7showposE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base7unitbufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base8internalE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base8showbaseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base9__xindex_E', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base9basefieldE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base9boolalphaE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base9showpointE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_base9uppercaseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_baseD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_baseD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28ios_baseD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28messagesIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28messagesIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIcE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIcEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIcEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIwE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIwEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIwEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28numpunctIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__28valarrayImE6resizeEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28valarrayImEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28valarrayImEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28valarrayImED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__28valarrayImED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_PKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIcE17__stage2_int_prepERNS_8ios_baseERc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_PKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIwE17__stage2_int_prepERNS_8ios_baseERw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29basic_iosIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZNSt3__29strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29strstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__29to_stringEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZNSt3__2plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__ZNSt8bad_castC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt8bad_castD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt8bad_castD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocC1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocC1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocC2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocC2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9bad_allocD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9bad_allocD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9exceptionD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9exceptionD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9exceptionD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9exceptionD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9exceptionD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9exceptionD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9type_infoD0Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9type_infoD0Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9type_infoD1Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9type_infoD1Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZNSt9type_infoD2Ev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZNSt9type_infoD2Ev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt10unexpectedv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt10unexpectedv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt13get_terminatev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt13get_terminatev', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt13set_terminatePFvvE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt13set_terminatePFvvE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt14get_unexpectedv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt14get_unexpectedv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt14set_unexpectedPFvvE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt14set_unexpectedPFvvE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt15get_new_handlerv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt15get_new_handlerv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZSt15set_new_handlerPFvvE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt15set_new_handlerPFvvE', 'type': 'I'}
+{'is_defined': True, 'name': '__ZSt17__throw_bad_allocv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt17current_exceptionv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt17rethrow_exceptionSt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt18uncaught_exceptionv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt19uncaught_exceptionsv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZSt7nothrow', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZSt9terminatev', 'type': 'U'}
+{'is_defined': True, 'name': '__ZSt9terminatev', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTCNSt3__210istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__210ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__29strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__29strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTCNSt3__29strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTIDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIDs', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt12experimental19bad_optional_accessE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210__time_getE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210__time_putE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210ctype_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210money_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210moneypunctIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210moneypunctIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210moneypunctIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210moneypunctIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__210ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__211__money_getIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__211__money_getIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__211__money_putIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__211__money_putIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__211regex_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__212bad_weak_ptrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__212codecvt_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__212ctype_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__212ctype_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__212future_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__212strstreambufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__212system_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__213messages_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214__codecvt_utf8IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214__num_get_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214__num_put_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214__shared_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214collate_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214collate_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__214error_categoryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215__codecvt_utf16IwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215messages_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215messages_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215numpunct_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215numpunct_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__216__narrow_to_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__216__narrow_to_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217__assoc_sub_stateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217__widen_from_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217__widen_from_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217bad_function_callE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__217moneypunct_bynameIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__218__time_get_storageIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__218__time_get_storageIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__219__shared_weak_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__220__codecvt_utf8_utf16IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__220__time_get_c_storageIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__220__time_get_c_storageIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__224__libcpp_debug_exceptionE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__25ctypeIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__25ctypeIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__26locale5facetE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27codecvtIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27codecvtIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27codecvtIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27collateIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27collateIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28__c_nodeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28ios_base7failureE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28ios_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28messagesIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28messagesIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28numpunctIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28numpunctIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29__num_getIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29__num_getIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29__num_putIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29__num_putIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTINSt3__29time_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTIPDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPKy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPKy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIPy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIPy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt10bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt10bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt11logic_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt11logic_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt11range_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt11range_error', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTISt12bad_any_cast', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTISt12domain_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt12domain_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt12length_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt12length_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt12out_of_range', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt12out_of_range', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt13bad_exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt13bad_exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt13runtime_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt13runtime_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt14overflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt14overflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt15underflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt15underflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt16invalid_argument', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt16invalid_argument', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTISt16nested_exception', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTISt18bad_variant_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTISt19bad_optional_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTISt20bad_array_new_length', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt20bad_array_new_length', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt8bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt8bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt9bad_alloc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt9bad_alloc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt9exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt9exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTISt9type_info', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTISt9type_info', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTId', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTId', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTIy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTIy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv117__array_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv117__array_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv117__class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv117__class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv120__function_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv120__function_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt12experimental19bad_optional_accessE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210__time_getE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210__time_putE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210ctype_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210money_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210moneypunctIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__210ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__211__money_getIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__211__money_getIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__211__money_putIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__211__money_putIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__211regex_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__212bad_weak_ptrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__212codecvt_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__212ctype_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__212ctype_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__212future_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__212strstreambufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__212system_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__213messages_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214__codecvt_utf8IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214__num_get_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214__num_put_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214__shared_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214collate_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214collate_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__214error_categoryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215__codecvt_utf16IwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215messages_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215messages_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215numpunct_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215numpunct_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__216__narrow_to_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__216__narrow_to_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217__assoc_sub_stateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217__widen_from_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217__widen_from_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217bad_function_callE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__217moneypunct_bynameIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__218__time_get_storageIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__218__time_get_storageIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__219__shared_weak_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__220__codecvt_utf8_utf16IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__220__time_get_c_storageIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__220__time_get_c_storageIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__224__libcpp_debug_exceptionE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__25ctypeIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__25ctypeIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__26locale5facetE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27codecvtIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27codecvtIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27codecvtIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27collateIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27collateIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28__c_nodeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28ios_base7failureE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28ios_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28messagesIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28messagesIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28numpunctIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28numpunctIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29__num_getIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29__num_getIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29__num_putIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29__num_putIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSNSt3__29time_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTSPDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKDi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKDi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKDn', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKDn', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKDs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKDs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPKy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPKy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSPy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSPy', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt10bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt10bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt11logic_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt11logic_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt11range_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt11range_error', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTSSt12bad_any_cast', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTSSt12domain_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt12domain_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt12length_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt12length_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt12out_of_range', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt12out_of_range', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt13bad_exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt13bad_exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt13runtime_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt13runtime_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt14overflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt14overflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt15underflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt15underflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt16invalid_argument', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt16invalid_argument', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTSSt16nested_exception', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSSt18bad_variant_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTSSt19bad_optional_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTSSt20bad_array_new_length', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt20bad_array_new_length', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt8bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt8bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt9bad_alloc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt9bad_alloc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt9exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt9exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSSt9type_info', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSSt9type_info', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSa', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSa', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSb', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSb', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSd', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSd', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSe', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSe', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSf', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSf', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSh', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSh', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSi', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSi', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSj', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSj', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSl', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSl', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSm', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSm', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSs', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSs', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSt', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSt', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSv', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSv', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSw', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSw', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSx', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSx', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTSy', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTSy', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTTNSt3__210istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__210ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTTNSt3__29strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv117__array_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv117__array_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv117__class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv117__class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv120__function_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv120__function_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt12experimental19bad_optional_accessE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__210istrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__210moneypunctIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__210ostrstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__211regex_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__212bad_weak_ptrE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__212ctype_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__212ctype_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__212future_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__212strstreambufE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__212system_errorE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__213basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__213basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__213basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__213basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214__codecvt_utf8IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214__shared_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214codecvt_bynameIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214collate_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214collate_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__214error_categoryE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDiLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDiLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDsLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IDsLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215__codecvt_utf16IwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215messages_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215messages_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215numpunct_bynameIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215numpunct_bynameIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__215time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__216__narrow_to_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__216__narrow_to_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217__assoc_sub_stateE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217__widen_from_utf8ILm16EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217__widen_from_utf8ILm32EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217bad_function_callE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIcLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIcLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIwLb0EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__217moneypunct_bynameIwLb1EEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__219__shared_weak_countE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IDiEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IDsEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__220__codecvt_utf8_utf16IwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__224__libcpp_debug_exceptionE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__25ctypeIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__25ctypeIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__26locale5facetE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27codecvtIDic11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27codecvtIDsc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27codecvtIcc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27codecvtIwc11__mbstate_tEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27collateIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27collateIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__27num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28__c_nodeE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28ios_base7failureE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28ios_baseE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28messagesIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28messagesIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28numpunctIcEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28numpunctIwEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__28time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__29basic_iosIcNS_11char_traitsIcEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__29basic_iosIwNS_11char_traitsIwEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__29money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__29money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__29money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__29money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVNSt3__29strstreamE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVSt10bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt10bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt11logic_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt11logic_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt11range_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt11range_error', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTVSt12bad_any_cast', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVSt12domain_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt12domain_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt12length_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt12length_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt12out_of_range', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt12out_of_range', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt13bad_exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt13bad_exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt13runtime_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt13runtime_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt14overflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt14overflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt15underflow_error', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt15underflow_error', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt16invalid_argument', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt16invalid_argument', 'type': 'I'}
+{'is_defined': True, 'name': '__ZTVSt16nested_exception', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVSt18bad_variant_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '__ZTVSt19bad_optional_access', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '__ZTVSt20bad_array_new_length', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt20bad_array_new_length', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt8bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt8bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt9bad_alloc', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt9bad_alloc', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt9exception', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt9exception', 'type': 'I'}
+{'is_defined': False, 'name': '__ZTVSt9type_info', 'type': 'U'}
+{'is_defined': True, 'name': '__ZTVSt9type_info', 'type': 'I'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__29strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZThn16_NSt3__29strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__210istrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__210istrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__210ostrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__210ostrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__213basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__214basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__29strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZTv0_n24_NSt3__29strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdaPvmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZdlPvmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__Znam', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnamRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnamSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnamSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__Znwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnwmRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnwmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '__ZnwmSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': False, 'name': '___cxa_allocate_exception', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_allocate_exception', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_atexit', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_bad_cast', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_bad_cast', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_bad_typeid', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_bad_typeid', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_begin_catch', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_begin_catch', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_call_unexpected', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_call_unexpected', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_current_exception_type', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_current_exception_type', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_current_primary_exception', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_decrement_exception_refcount', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_deleted_virtual', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_deleted_virtual', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_demangle', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_demangle', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_end_catch', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_end_catch', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_free_exception', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_free_exception', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_get_exception_ptr', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_get_exception_ptr', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_get_globals', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_get_globals', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_get_globals_fast', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_get_globals_fast', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_guard_abort', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_guard_abort', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_guard_acquire', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_guard_acquire', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_guard_release', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_guard_release', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_increment_exception_refcount', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_pure_virtual', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_pure_virtual', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_rethrow', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_rethrow', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_rethrow_primary_exception', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_throw', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_throw', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_uncaught_exceptions', 'type': 'U'}
+{'is_defined': False, 'name': '___cxa_vec_cctor', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_cctor', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_cleanup', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_cleanup', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_ctor', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_ctor', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_delete', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_delete', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_delete2', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_delete2', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_delete3', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_delete3', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_dtor', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_dtor', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_new', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_new', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_new2', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_new2', 'type': 'I'}
+{'is_defined': False, 'name': '___cxa_vec_new3', 'type': 'U'}
+{'is_defined': True, 'name': '___cxa_vec_new3', 'type': 'I'}
+{'is_defined': False, 'name': '___dynamic_cast', 'type': 'U'}
+{'is_defined': True, 'name': '___dynamic_cast', 'type': 'I'}
+{'is_defined': False, 'name': '___gxx_personality_v0', 'type': 'U'}
+{'is_defined': True, 'name': '___gxx_personality_v0', 'type': 'I'}
diff --git a/lib/abi/x86_64-unknown-linux-gnu.v1.abilist b/lib/abi/x86_64-unknown-linux-gnu.v1.abilist
index 0be9eb2fc..8a31ff82a 100644
--- a/lib/abi/x86_64-unknown-linux-gnu.v1.abilist
+++ b/lib/abi/x86_64-unknown-linux-gnu.v1.abilist
@@ -1,1861 +1,1861 @@
-{'name': '_ZNKSt11logic_error4whatEv', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNKSt12bad_any_cast4whatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt13runtime_error4whatEv', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNKSt16nested_exception14rethrow_nestedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt18bad_variant_access4whatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt19bad_optional_access4whatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110error_code7messageEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db15__decrementableEPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db15__find_c_from_iEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db15__subscriptableEPKvl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db17__dereferenceableEPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db17__find_c_and_lockEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db8__find_cEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__111__libcpp_db9__addableEPKvl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112bad_weak_ptr4whatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE10do_scan_isEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE11do_scan_notEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE5do_isEtw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEwc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__112strstreambuf6pcountEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__113random_device7entropyEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IwE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114error_category10equivalentERKNS_10error_codeEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__114error_category23default_error_conditionEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__115error_condition7messageEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__118__time_get_storageIcE15__do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__118__time_get_storageIwE15__do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIcE3__XEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIcE3__cEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIcE3__rEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIcE3__xEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIcE7__am_pmEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIcE7__weeksEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIcE8__monthsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIwE3__XEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIwE3__cEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIwE3__rEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIwE3__xEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIwE7__am_pmEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIwE7__weeksEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__time_get_c_storageIwE8__monthsEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__124__libcpp_debug_exception4whatEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE10do_tolowerEPcPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE10do_tolowerEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE10do_toupperEPcPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE10do_toupperEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE8do_widenEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIcE9do_narrowEcc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE10do_scan_isEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE10do_tolowerEPwPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE10do_tolowerEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE10do_toupperEPwPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE10do_toupperEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE11do_scan_notEtPKwS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE5do_isEPKwS3_Pt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE5do_isEtw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE8do_widenEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__15ctypeIwE9do_narrowEwc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__16locale4nameEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__16locale9has_facetERNS0_2idE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__16locale9use_facetERNS0_2idE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__16localeeqERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17collateIcE12do_transformEPKcS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17collateIcE7do_hashEPKcS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17collateIwE12do_transformEPKwS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17collateIwE7do_hashEPKwS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18ios_base6getlocEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18messagesIcE8do_closeEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18messagesIwE8do_closeEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIcE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIcE11do_truenameEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIcE12do_falsenameEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIcE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIcE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIwE11do_groupingEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIwE11do_truenameEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIwE12do_falsenameEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIwE16do_decimal_pointEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18numpunctIwE16do_thousands_sepEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_errorC1EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_errorC1ERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_errorC2EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_errorC2ERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_errorD2Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt11logic_erroraSERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt12experimental19bad_optional_accessD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt12experimental19bad_optional_accessD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt12experimental19bad_optional_accessD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt12length_errorD1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt12out_of_rangeD1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt13exception_ptrC1ERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13exception_ptrC2ERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13exception_ptrD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13exception_ptrD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13exception_ptraSERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorC1EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorC1ERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorC2EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorC2ERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorD1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_errorD2Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt13runtime_erroraSERKS_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt14overflow_errorD1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt16invalid_argumentD1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt16nested_exceptionC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt16nested_exceptionC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt16nested_exceptionD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt16nested_exceptionD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt16nested_exceptionD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt19bad_optional_accessD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt19bad_optional_accessD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt19bad_optional_accessD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_getC1EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_getC2EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_getD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_getD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_putC1EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_putC2EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_putD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110__time_putD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110adopt_lockE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__110ctype_base5alnumE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5alphaE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5blankE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5cntrlE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5digitE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5graphE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5lowerE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5printE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5punctE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5spaceE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base5upperE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110ctype_base6xdigitE', 'is_defined': True, 'type': 'OBJECT', 'size': 2}
-{'name': '_ZNSt3__110defer_lockE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__110istrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110istrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110istrstreamD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110moneypunctIcLb0EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__110moneypunctIcLb0EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__110moneypunctIcLb1EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__110moneypunctIcLb1EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__110moneypunctIwLb0EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__110moneypunctIwLb0EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__110moneypunctIwLb1EE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__110moneypunctIwLb1EE4intlE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__110ostrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110ostrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110ostrstreamD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__110to_wstringEy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__call_onceERVmPvPFvS2_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db10__insert_cEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db10__insert_iEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db11__insert_icEPvPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db15__iterator_copyEPvPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db16__invalidate_allEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db4swapEPvS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db9__erase_cEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_db9__erase_iEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_dbC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_dbC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_dbD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__libcpp_dbD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111regex_errorD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111regex_errorD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111regex_errorD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111timed_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111timed_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111timed_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111timed_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111timed_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111timed_mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111timed_mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__111try_to_lockE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112__do_nothingEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__get_sp_mutEPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__next_primeEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__rs_default4__c_E', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__112__rs_defaultC1ERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__rs_defaultC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__rs_defaultC2ERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__rs_defaultC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__rs_defaultD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__rs_defaultD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112__rs_defaultclEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112bad_weak_ptrD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112bad_weak_ptrD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112bad_weak_ptrD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'is_defined': True, 'type': 'OBJECT', 'size': 8}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'is_defined': True, 'type': 'OBJECT', 'size': 8}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIcEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIcEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIwEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIwEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112ctype_bynameIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112future_errorC1ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112future_errorC2ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112future_errorD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112future_errorD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112future_errorD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112placeholders2_1E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_2E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_3E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_4E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_5E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_6E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_7E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_8E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders2_9E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112placeholders3_10E', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__112strstreambuf3strEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf4swapERS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf6__initEPclS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf6freezeEb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf8overflowEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf9pbackfailEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambuf9underflowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1EPFPvmEPFvS1_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1EPKal', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1EPKcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1EPKhl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1EPalS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1EPclS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1EPhlS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC1El', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2EPFPvmEPFvS1_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2EPKal', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2EPKcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2EPKhl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2EPalS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2EPclS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2EPhlS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufC2El', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112strstreambufD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC1ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC1ENS_10error_codeEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC2ENS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC2ENS_10error_codeEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__112system_errorD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113allocator_argE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreElj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113random_deviceD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113random_deviceD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113random_deviceclEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113shared_futureIvED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113shared_futureIvED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__113shared_futureIvEaSERKS1_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__get_const_dbEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__num_get_base5__srcE', 'is_defined': True, 'type': 'OBJECT', 'size': 33}
-{'name': '_ZNSt3__114__num_put_base12__format_intEPcPKcbj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__num_put_base14__format_floatEPcPKcj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__shared_count12__add_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__shared_count16__release_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__shared_countD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__shared_countD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114__shared_countD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIcEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIcEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIwEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIwEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114collate_bynameIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114error_categoryC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114error_categoryD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114error_categoryD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__114error_categoryD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115__get_classnameEPKcb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115__thread_structC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115__thread_structC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115__thread_structD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115__thread_structD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115future_categoryEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcE6__initEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwE6__initEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115numpunct_bynameIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115recursive_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115recursive_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115recursive_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115recursive_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115recursive_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115recursive_mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115recursive_mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__115system_categoryEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116__narrow_to_utf8ILm16EED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116__narrow_to_utf8ILm16EED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116__narrow_to_utf8ILm16EED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116__narrow_to_utf8ILm32EED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116__narrow_to_utf8ILm32EED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116__narrow_to_utf8ILm32EED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__116generic_categoryEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state12__make_readyEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state16__on_zero_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state4copyEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state4waitEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state9__executeEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__assoc_sub_state9set_valueEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__widen_from_utf8ILm16EED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__widen_from_utf8ILm16EED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__widen_from_utf8ILm16EED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__widen_from_utf8ILm32EED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__widen_from_utf8ILm32EED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117__widen_from_utf8ILm32EED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117declare_reachableEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117iostream_categoryEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIcEC1EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIcEC2EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIwEC1EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIwEC2EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118condition_variable10notify_allEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118condition_variable10notify_oneEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118condition_variableD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118condition_variableD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118get_pointer_safetyEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutex11lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutex13unlock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutex15try_lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__118shared_timed_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_base11lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_base13unlock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_base15try_lock_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_base4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_base6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_base8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_baseC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_mutex_baseC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_count10__add_weakEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_count12__add_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_count14__release_weakEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_count16__release_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_count4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_countD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_countD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__shared_weak_countD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119__thread_local_dataEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119declare_no_pointersEPcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__119piecewise_constructE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__120__get_collation_nameEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__120__throw_system_errorEiPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121__throw_runtime_errorEPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121__undeclare_reachableEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121recursive_timed_mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121recursive_timed_mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121recursive_timed_mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121recursive_timed_mutexC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121recursive_timed_mutexC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121recursive_timed_mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121recursive_timed_mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__121undeclare_no_pointersEPcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__123__libcpp_debug_functionE', 'is_defined': True, 'type': 'OBJECT', 'size': 8}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__124__libcpp_debug_exceptionD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__13cinE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
-{'name': '_ZNSt3__14cerrE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
-{'name': '_ZNSt3__14clogE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
-{'name': '_ZNSt3__14coutE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
-{'name': '_ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__14wcinE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
-{'name': '_ZNSt3__15alignEmmRPvRm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcE13classic_tableEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcE21__classic_lower_tableEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcE21__classic_upper_tableEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__15ctypeIcEC1EPKtbm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcEC2EPKtbm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__15ctypeIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15ctypeIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15mutex4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15mutex6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15mutex8try_lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15mutexD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15mutexD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__15wcerrE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
-{'name': '_ZNSt3__15wclogE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
-{'name': '_ZNSt3__15wcoutE', 'is_defined': True, 'type': 'OBJECT', 'size': 160}
-{'name': '_ZNSt3__16__clocEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__itoa8__u64toaEmPc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__itoa8__u32toaEjPc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16chrono12steady_clock3nowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16chrono12steady_clock9is_steadyE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__16chrono12system_clock11from_time_tEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16chrono12system_clock3nowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16chrono12system_clock9is_steadyE', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16futureIvE3getEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16futureIvED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16futureIvED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16gslice6__initEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale2id5__getEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale2id6__initEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale2id9__next_idE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale3allE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale4noneE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale4timeE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale5ctypeE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale5facet16__on_zero_sharedEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale5facetD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale5facetD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale5facetD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale6globalERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale7classicEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale7collateE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale7numericE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale8__globalEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16locale8messagesE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16locale8monetaryE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__16localeC1EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC1ERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC1ERKS0_PKci', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC1ERKS0_S2_i', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC2EPKc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC2ERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC2ERKS0_PKci', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC2ERKS0_S2_i', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16localeaSERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16thread20hardware_concurrencyEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16thread4joinEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16thread6detachEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16threadD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__16threadD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17codecvtIDic11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIDic11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIDic11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17codecvtIcc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIcc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIcc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17codecvtIwc11__mbstate_tED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17collateIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17collateIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17collateIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17collateIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17collateIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17collateIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17collateIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17collateIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__17promiseIvE10get_futureEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvE24set_value_at_thread_exitEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvE9set_valueEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvEC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvEC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__17promiseIvED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__c_node5__addEPNS_8__i_nodeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__c_nodeD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__c_nodeD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__c_nodeD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__get_dbEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__i_nodeD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__i_nodeD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__rs_getEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__sp_mut4lockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18__sp_mut6unlockEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base10floatfieldE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base10scientificE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base11adjustfieldE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base15sync_with_stdioEb', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base16__call_callbacksENS0_5eventE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base2inE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base3appE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base3ateE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base3decE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base3hexE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base3octE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base3outE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base4InitC1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base4InitC2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base4InitD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base4InitD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base4initEPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base4leftE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base4moveERS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base4swapERS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base5clearEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base5fixedE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base5imbueERKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base5iwordEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base5pwordEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base5rightE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base5truncE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base6badbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base6binaryE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base6eofbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base6skipwsE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base6xallocEv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7copyfmtERKS0_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7failbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7failureD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7failureD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7failureD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_base7goodbitE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base7showposE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base7unitbufE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base8internalE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base8showbaseE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base9__xindex_E', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base9basefieldE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base9boolalphaE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base9showpointE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_base9uppercaseE', 'is_defined': True, 'type': 'OBJECT', 'size': 4}
-{'name': '_ZNSt3__18ios_baseD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_baseD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18ios_baseD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18messagesIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18messagesIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18numpunctIcE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18numpunctIcEC1Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIcEC2Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIcED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIcED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIcED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIwE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18numpunctIwEC1Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIwEC2Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIwED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIwED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18numpunctIwED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__18valarrayImE6resizeEmm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18valarrayImEC1Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18valarrayImEC2Em', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18valarrayImED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__18valarrayImED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZNSt3__19strstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19strstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19strstreamD2Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEd', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEe', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEf', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEi', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEj', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEl', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEx', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__19to_stringEy', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZNSt8bad_castC1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt8bad_castD1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt8bad_castD2Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt9bad_allocC1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt9bad_allocD1Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZNSt9exceptionD2Ev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZSt15get_new_handlerv', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZSt17__throw_bad_allocv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZSt17current_exceptionv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZSt17rethrow_exceptionSt13exception_ptr', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZSt18uncaught_exceptionv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZSt19uncaught_exceptionsv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZSt7nothrow', 'is_defined': True, 'type': 'OBJECT', 'size': 1}
-{'name': '_ZSt9terminatev', 'is_defined': False, 'type': 'FUNC'}
-{'name': '_ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 120}
-{'name': '_ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTINSt12experimental15fundamentals_v112bad_any_castE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt12experimental19bad_optional_accessE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__110__time_getE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__110__time_putE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__110ctype_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__110money_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__110moneypunctIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__110moneypunctIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__110moneypunctIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__110moneypunctIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__111__money_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__111__money_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__111__money_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__111__money_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__111regex_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__112bad_weak_ptrE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__112codecvt_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__112ctype_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__112ctype_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__112future_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__112strstreambufE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__112system_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__113messages_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__114__codecvt_utf8IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114__codecvt_utf8IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114__codecvt_utf8IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114__num_get_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__114__num_put_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__114__shared_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114collate_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114collate_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__114error_categoryE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115__codecvt_utf16IwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115__codecvt_utf16IwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__115messages_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115messages_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115numpunct_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115numpunct_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__116__narrow_to_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__116__narrow_to_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__117__assoc_sub_stateE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__117__widen_from_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__117__widen_from_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__117moneypunct_bynameIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__117moneypunct_bynameIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__117moneypunct_bynameIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__117moneypunct_bynameIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__118__time_get_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__118__time_get_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__119__shared_weak_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__120__codecvt_utf8_utf16IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__120__time_get_c_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__120__time_get_c_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__124__libcpp_debug_exceptionE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__15ctypeIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__15ctypeIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__16locale5facetE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__17codecvtIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__17codecvtIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__17codecvtIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__17collateIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__17collateIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__18__c_nodeE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__18ios_base7failureE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__18ios_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTINSt3__18messagesIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__18messagesIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__18numpunctIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__18numpunctIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 72}
-{'name': '_ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 72}
-{'name': '_ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__19__num_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__19__num_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__19__num_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__19__num_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTINSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTINSt3__19time_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTISt11logic_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt12bad_any_cast', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTISt12length_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt12out_of_range', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt13runtime_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt14overflow_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt16invalid_argument', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt16nested_exception', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTISt18bad_variant_access', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTISt19bad_optional_access', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTISt8bad_cast', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt9bad_alloc', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTISt9exception', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'is_defined': True, 'type': 'OBJECT', 'size': 50}
-{'name': '_ZTSNSt12experimental19bad_optional_accessE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTSNSt3__110__time_getE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__110__time_putE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__110ctype_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__110money_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__110moneypunctIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__110moneypunctIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__110moneypunctIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__110moneypunctIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__111__money_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__111__money_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__111__money_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__111__money_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__111regex_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
-{'name': '_ZTSNSt3__112bad_weak_ptrE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
-{'name': '_ZTSNSt3__112codecvt_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
-{'name': '_ZTSNSt3__112ctype_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 26}
-{'name': '_ZTSNSt3__112ctype_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 26}
-{'name': '_ZTSNSt3__112future_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
-{'name': '_ZTSNSt3__112strstreambufE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
-{'name': '_ZTSNSt3__112system_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
-{'name': '_ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
-{'name': '_ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
-{'name': '_ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
-{'name': '_ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 47}
-{'name': '_ZTSNSt3__113messages_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTSNSt3__114__codecvt_utf8IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
-{'name': '_ZTSNSt3__114__codecvt_utf8IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
-{'name': '_ZTSNSt3__114__codecvt_utf8IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__114__num_get_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__114__num_put_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__114__shared_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
-{'name': '_ZTSNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 43}
-{'name': '_ZTSNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 43}
-{'name': '_ZTSNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
-{'name': '_ZTSNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
-{'name': '_ZTSNSt3__114collate_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__114collate_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__114error_categoryE', 'is_defined': True, 'type': 'OBJECT', 'size': 25}
-{'name': '_ZTSNSt3__115__codecvt_utf16IDiLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__115__codecvt_utf16IDiLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__115__codecvt_utf16IDsLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__115__codecvt_utf16IDsLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__115__codecvt_utf16IwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 33}
-{'name': '_ZTSNSt3__115__codecvt_utf16IwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 33}
-{'name': '_ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 49}
-{'name': '_ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 49}
-{'name': '_ZTSNSt3__115messages_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
-{'name': '_ZTSNSt3__115messages_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
-{'name': '_ZTSNSt3__115numpunct_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
-{'name': '_ZTSNSt3__115numpunct_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 29}
-{'name': '_ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
-{'name': '_ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
-{'name': '_ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
-{'name': '_ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 77}
-{'name': '_ZTSNSt3__116__narrow_to_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__116__narrow_to_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__117__assoc_sub_stateE', 'is_defined': True, 'type': 'OBJECT', 'size': 28}
-{'name': '_ZTSNSt3__117__widen_from_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__117__widen_from_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__118__time_get_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTSNSt3__118__time_get_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTSNSt3__119__shared_weak_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 30}
-{'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__120__codecvt_utf8_utf16IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__120__time_get_c_storageIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__120__time_get_c_storageIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__124__libcpp_debug_exceptionE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__15ctypeIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
-{'name': '_ZTSNSt3__15ctypeIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
-{'name': '_ZTSNSt3__16locale5facetE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
-{'name': '_ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 35}
-{'name': '_ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 34}
-{'name': '_ZTSNSt3__17collateIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 20}
-{'name': '_ZTSNSt3__17collateIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 20}
-{'name': '_ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
-{'name': '_ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
-{'name': '_ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
-{'name': '_ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 68}
-{'name': '_ZTSNSt3__18__c_nodeE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
-{'name': '_ZTSNSt3__18ios_base7failureE', 'is_defined': True, 'type': 'OBJECT', 'size': 26}
-{'name': '_ZTSNSt3__18ios_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 18}
-{'name': '_ZTSNSt3__18messagesIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__18messagesIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__18numpunctIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__18numpunctIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
-{'name': '_ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
-{'name': '_ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
-{'name': '_ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 69}
-{'name': '_ZTSNSt3__19__num_getIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
-{'name': '_ZTSNSt3__19__num_getIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
-{'name': '_ZTSNSt3__19__num_putIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
-{'name': '_ZTSNSt3__19__num_putIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 22}
-{'name': '_ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
-{'name': '_ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 42}
-{'name': '_ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
-{'name': '_ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
-{'name': '_ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
-{'name': '_ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 70}
-{'name': '_ZTSNSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 19}
-{'name': '_ZTSNSt3__19time_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 19}
-{'name': '_ZTSSt12bad_any_cast', 'is_defined': True, 'type': 'OBJECT', 'size': 17}
-{'name': '_ZTSSt16nested_exception', 'is_defined': True, 'type': 'OBJECT', 'size': 21}
-{'name': '_ZTSSt18bad_variant_access', 'is_defined': True, 'type': 'OBJECT', 'size': 23}
-{'name': '_ZTSSt19bad_optional_access', 'is_defined': True, 'type': 'OBJECT', 'size': 24}
-{'name': '_ZTTNSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTTNSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 16}
-{'name': '_ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTTNSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVN10__cxxabiv117__class_type_infoE', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVN10__cxxabiv120__si_class_type_infoE', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVN10__cxxabiv121__vmi_class_type_infoE', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt12experimental19bad_optional_accessE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__110istrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__110moneypunctIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__110moneypunctIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__110moneypunctIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__110moneypunctIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__110ostrstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__111regex_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__112bad_weak_ptrE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__112ctype_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
-{'name': '_ZTVNSt3__112ctype_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 136}
-{'name': '_ZTVNSt3__112future_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__112strstreambufE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
-{'name': '_ZTVNSt3__112system_errorE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__114__codecvt_utf8IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__114__codecvt_utf8IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__114__codecvt_utf8IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__114__shared_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 120}
-{'name': '_ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__114collate_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__114collate_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__114error_categoryE', 'is_defined': True, 'type': 'OBJECT', 'size': 72}
-{'name': '_ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
-{'name': '_ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
-{'name': '_ZTVNSt3__115messages_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__115messages_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__115numpunct_bynameIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__115numpunct_bynameIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 224}
-{'name': '_ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 224}
-{'name': '_ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
-{'name': '_ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
-{'name': '_ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__117__assoc_sub_stateE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
-{'name': '_ZTVNSt3__117__widen_from_utf8ILm16EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__117__widen_from_utf8ILm32EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'is_defined': True, 'type': 'OBJECT', 'size': 112}
-{'name': '_ZTVNSt3__119__shared_weak_countE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__124__libcpp_debug_exceptionE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__15ctypeIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
-{'name': '_ZTVNSt3__15ctypeIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 136}
-{'name': '_ZTVNSt3__16locale5facetE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'is_defined': True, 'type': 'OBJECT', 'size': 96}
-{'name': '_ZTVNSt3__17collateIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__17collateIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
-{'name': '_ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 128}
-{'name': '_ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
-{'name': '_ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 104}
-{'name': '_ZTVNSt3__18__c_nodeE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__18ios_base7failureE', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVNSt3__18ios_baseE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTVNSt3__18messagesIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__18messagesIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 64}
-{'name': '_ZTVNSt3__18numpunctIcEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__18numpunctIwEE', 'is_defined': True, 'type': 'OBJECT', 'size': 80}
-{'name': '_ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
-{'name': '_ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 168}
-{'name': '_ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
-{'name': '_ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 48}
-{'name': '_ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'is_defined': True, 'type': 'OBJECT', 'size': 56}
-{'name': '_ZTVNSt3__19strstreamE', 'is_defined': True, 'type': 'OBJECT', 'size': 120}
-{'name': '_ZTVSt11logic_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVSt12bad_any_cast', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVSt12length_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVSt12out_of_range', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVSt13runtime_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVSt14overflow_error', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVSt16invalid_argument', 'is_defined': False, 'type': 'OBJECT', 'size': 0}
-{'name': '_ZTVSt16nested_exception', 'is_defined': True, 'type': 'OBJECT', 'size': 32}
-{'name': '_ZTVSt18bad_variant_access', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZTVSt19bad_optional_access', 'is_defined': True, 'type': 'OBJECT', 'size': 40}
-{'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZThn16_NSt3__19strstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZThn16_NSt3__19strstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__110istrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__110istrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__110ostrstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__110ostrstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__19strstreamD0Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZTv0_n24_NSt3__19strstreamD1Ev', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdaPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdaPvRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdaPvSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdaPvSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdaPvm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdaPvmSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdlPv', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdlPvRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdlPvSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdlPvSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdlPvm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZdlPvmSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_Znam', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZnamRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZnamSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZnamSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_Znwm', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZnwmRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZnwmSt11align_val_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '_ZnwmSt11align_val_tRKSt9nothrow_t', 'is_defined': True, 'type': 'FUNC'}
-{'name': '__cxa_allocate_exception', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_begin_catch', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_current_primary_exception', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_decrement_exception_refcount', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_end_catch', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_free_exception', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_guard_abort', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_guard_acquire', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_guard_release', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_increment_exception_refcount', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_pure_virtual', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_rethrow', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_rethrow_primary_exception', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_throw', 'is_defined': False, 'type': 'FUNC'}
-{'name': '__cxa_uncaught_exceptions', 'is_defined': False, 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNKSt11logic_error4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt12bad_any_cast4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNKSt13runtime_error4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt16nested_exception14rethrow_nestedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt18bad_variant_access4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt19bad_optional_access4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110error_code7messageEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db15__decrementableEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db15__find_c_from_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db15__subscriptableEPKvl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db17__dereferenceableEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db17__find_c_and_lockEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db8__find_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db9__addableEPKvl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112bad_weak_ptr4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_scan_isEtPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE11do_scan_notEtPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE5do_isEtw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEwc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__112strstreambuf6pcountEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__113random_device7entropyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114error_category10equivalentERKNS_10error_codeEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__114error_category23default_error_conditionEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__115error_condition7messageEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__118__time_get_storageIcE15__do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__118__time_get_storageIwE15__do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__XEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__cEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__rEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__xEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE7__am_pmEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE7__weeksEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE8__monthsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__XEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__cEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__rEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__xEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE7__am_pmEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE7__weeksEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE8__monthsEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__124__libcpp_debug_exception4whatEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_tolowerEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_toupperEPcPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_toupperEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE9do_narrowEcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_scan_isEtPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_tolowerEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_toupperEPwPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_toupperEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE11do_scan_notEtPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE5do_isEPKwS3_Pt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE5do_isEtw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE8do_widenEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE9do_narrowEwc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__16locale4nameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__16locale9has_facetERNS0_2idE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__16locale9use_facetERNS0_2idE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__16localeeqERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17collateIcE12do_transformEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17collateIcE7do_hashEPKcS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17collateIwE12do_transformEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17collateIwE7do_hashEPKwS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18ios_base6getlocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18messagesIcE8do_closeEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18messagesIwE8do_closeEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE11do_truenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE12do_falsenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE11do_groupingEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE11do_truenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE12do_falsenameEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE16do_decimal_pointEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE16do_thousands_sepEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt11logic_errorC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt11logic_errorC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt11logic_errorC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt11logic_errorC2ERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt11logic_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt11logic_erroraSERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt12experimental19bad_optional_accessD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt12experimental19bad_optional_accessD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt12experimental19bad_optional_accessD2Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt12length_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt12out_of_rangeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13exception_ptrC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13exception_ptrC2ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13exception_ptrD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13exception_ptrD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13exception_ptraSERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13runtime_errorC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13runtime_errorC1ERKS_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13runtime_errorC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13runtime_errorC2ERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt13runtime_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt13runtime_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt13runtime_erroraSERKS_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt14overflow_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt16invalid_argumentD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt16nested_exceptionC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt16nested_exceptionC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt16nested_exceptionD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt16nested_exceptionD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt16nested_exceptionD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt19bad_optional_accessD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt19bad_optional_accessD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt19bad_optional_accessD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_getC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_getC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_getD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_getD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_putC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_putC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_putD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110__time_putD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110adopt_lockE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5alnumE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5alphaE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5blankE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5cntrlE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5digitE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5graphE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5lowerE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5printE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5punctE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5spaceE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base5upperE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ctype_base6xdigitE', 'size': 2, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110defer_lockE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110istrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110istrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110istrstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE4intlE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE4intlE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE4intlE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb1EE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb1EE4intlE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__110ostrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110ostrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110ostrstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__110to_wstringEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__call_onceERVmPvPFvS2_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db10__insert_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db10__insert_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db11__insert_icEPvPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db15__iterator_copyEPvPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db16__invalidate_allEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db4swapEPvS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db9__erase_cEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db9__erase_iEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111regex_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111regex_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111regex_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111timed_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111timed_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__111try_to_lockE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112__do_nothingEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__get_sp_mutEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__next_primeEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_default4__c_E', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultclEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112bad_weak_ptrD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112bad_weak_ptrD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112bad_weak_ptrD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 8, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 8, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112future_errorC1ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112future_errorC2ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112future_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112future_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112future_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_1E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_2E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_3E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_4E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_5E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_6E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_7E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_8E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders2_9E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112placeholders3_10E', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf3strEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf4swapERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf6__initEPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf6freezeEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambuf9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPFPvmEPFvS1_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPKal', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPKhl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPalS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPhlS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1El', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPFPvmEPFvS1_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPKal', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPKhl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPalS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPclS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPhlS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2El', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112strstreambufD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC1ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC1ENS_10error_codeEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC2ENS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC2ENS_10error_codeEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__112system_errorD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113allocator_argE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreElj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113random_deviceD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113random_deviceD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113random_deviceclEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113shared_futureIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113shared_futureIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__113shared_futureIvEaSERKS1_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__get_const_dbEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__num_get_base5__srcE', 'size': 33, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__114__num_put_base12__format_intEPcPKcbj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__num_put_base14__format_floatEPcPKcj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__shared_count12__add_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__shared_count16__release_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__shared_countD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__shared_countD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114__shared_countD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114error_categoryC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114error_categoryD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114error_categoryD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__114error_categoryD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115__get_classnameEPKcb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115__thread_structC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115__thread_structC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115__thread_structD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115__thread_structD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115future_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcE6__initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwE6__initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115recursive_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115recursive_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115recursive_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__115system_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm16EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm16EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm16EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm32EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm32EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm32EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__116generic_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state12__make_readyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state16__on_zero_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state4copyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state4waitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state9__executeEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state9set_valueEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm16EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm16EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm16EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm32EED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm32EED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm32EED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117declare_reachableEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117iostream_categoryEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118condition_variable10notify_allEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118condition_variable10notify_oneEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118condition_variableD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118condition_variableD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118get_pointer_safetyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex11lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex13unlock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex15try_lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base11lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base13unlock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base15try_lock_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_baseC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_baseC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count10__add_weakEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count12__add_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count14__release_weakEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count16__release_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_countD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_countD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_countD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119__thread_local_dataEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119declare_no_pointersEPcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__119piecewise_constructE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__120__get_collation_nameEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__120__throw_system_errorEiPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121__throw_runtime_errorEPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121__undeclare_reachableEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__121undeclare_no_pointersEPcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__123__libcpp_debug_functionE', 'size': 8, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__13cinE', 'size': 168, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__14cerrE', 'size': 160, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__14clogE', 'size': 160, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__14coutE', 'size': 160, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__14wcinE', 'size': 168, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__15alignEmmRPvRm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcE13classic_tableEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcE21__classic_lower_tableEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcE21__classic_upper_tableEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcEC1EPKtbm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcEC2EPKtbm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIwE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15ctypeIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15mutex4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15mutex6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15mutex8try_lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15mutexD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15mutexD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__15wcerrE', 'size': 160, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__15wclogE', 'size': 160, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__15wcoutE', 'size': 160, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16__clocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__itoa8__u32toaEjPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__itoa8__u64toaEmPc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16chrono12steady_clock3nowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16chrono12steady_clock9is_steadyE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock11from_time_tEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock3nowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock9is_steadyE', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16futureIvE3getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16futureIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16futureIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16gslice6__initEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale2id5__getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale2id6__initEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale2id9__next_idE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale3allE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale4noneE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale4timeE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale5ctypeE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale5facet16__on_zero_sharedEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale5facetD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale5facetD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale5facetD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale6globalERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale7classicEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale7collateE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale7numericE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale8__globalEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16locale8messagesE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16locale8monetaryE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC1EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_PKci', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_S2_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC2EPKc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_PKci', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_S2_i', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16localeaSERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16thread20hardware_concurrencyEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16thread4joinEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16thread6detachEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16threadD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__16threadD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIcE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIwE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17collateIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvE10get_futureEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvE24set_value_at_thread_exitEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvE9set_valueEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvEC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvEC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__17promiseIvED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__c_node5__addEPNS_8__i_nodeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__c_nodeD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__c_nodeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__c_nodeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__get_dbEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__i_nodeD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__i_nodeD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__rs_getEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__sp_mut4lockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18__sp_mut6unlockEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base10floatfieldE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base10scientificE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base11adjustfieldE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base15sync_with_stdioEb', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base16__call_callbacksENS0_5eventE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base2inE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base3appE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base3ateE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base3decE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base3hexE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base3octE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base3outE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitC1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitC2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4initEPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4leftE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4moveERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base4swapERS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base5clearEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base5fixedE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base5imbueERKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base5iwordEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base5pwordEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base5rightE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base5truncE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base6badbitE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base6binaryE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base6eofbitE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base6skipwsE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base6xallocEv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7copyfmtERKS0_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failbitE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7goodbitE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7showposE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base7unitbufE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base8internalE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base8showbaseE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base9__xindex_E', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base9basefieldE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base9boolalphaE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base9showpointE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_base9uppercaseE', 'size': 4, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_baseD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_baseD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18ios_baseD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18messagesIcE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18messagesIwE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIcE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIcEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIcEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIcED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIcED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIcED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIwE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIwEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIwEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIwED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIwED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18numpunctIwED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__18valarrayImE6resizeEmm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18valarrayImEC1Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18valarrayImEC2Em', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18valarrayImED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__18valarrayImED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZNSt3__19strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19strstreamD2Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEd', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEe', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEf', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEi', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEj', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEl', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEx', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__19to_stringEy', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt8bad_castC1Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt8bad_castD1Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt8bad_castD2Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt9bad_allocC1Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt9bad_allocD1Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZNSt9exceptionD2Ev', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZSt15get_new_handlerv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZSt17__throw_bad_allocv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZSt17current_exceptionv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZSt17rethrow_exceptionSt13exception_ptr', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZSt18uncaught_exceptionv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZSt19uncaught_exceptionsv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZSt7nothrow', 'size': 1, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZSt9terminatev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 120, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt12experimental19bad_optional_accessE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110__time_getE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110__time_putE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110ctype_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110istrstreamE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110money_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110moneypunctIcLb0EEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110moneypunctIcLb1EEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110moneypunctIwLb0EEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110moneypunctIwLb1EEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__110ostrstreamE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__111__money_getIcEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__111__money_getIwEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__111__money_putIcEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__111__money_putIwEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__111regex_errorE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__112bad_weak_ptrE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__112codecvt_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__112ctype_bynameIcEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__112ctype_bynameIwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__112future_errorE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__112strstreambufE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__112system_errorE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__113messages_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114__codecvt_utf8IDiEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114__codecvt_utf8IDsEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114__codecvt_utf8IwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114__num_get_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114__num_put_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114__shared_countE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114collate_bynameIcEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114collate_bynameIwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__114error_categoryE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IwLb0EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IwLb1EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115messages_bynameIcEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115messages_bynameIwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115numpunct_bynameIcEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115numpunct_bynameIwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__116__narrow_to_utf8ILm16EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__116__narrow_to_utf8ILm32EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__117__assoc_sub_stateE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__117__widen_from_utf8ILm16EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__117__widen_from_utf8ILm32EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIcLb0EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIcLb1EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIwLb0EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIwLb1EEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__118__time_get_storageIcEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__118__time_get_storageIwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__119__shared_weak_countE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__120__codecvt_utf8_utf16IwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__120__time_get_c_storageIcEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__120__time_get_c_storageIwEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__124__libcpp_debug_exceptionE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__15ctypeIcEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__15ctypeIwEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__16locale5facetE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17codecvtIDic11__mbstate_tEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17codecvtIcc11__mbstate_tEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17codecvtIwc11__mbstate_tEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17collateIcEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17collateIwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18__c_nodeE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18ios_base7failureE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18ios_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18messagesIcEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18messagesIwEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18numpunctIcEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18numpunctIwEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 72, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 72, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19__num_getIcEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19__num_getIwEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19__num_putIcEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19__num_putIwEE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19strstreamE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTINSt3__19time_baseE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt11logic_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTISt12bad_any_cast', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt12length_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt12out_of_range', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt13runtime_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt14overflow_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt16invalid_argument', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTISt16nested_exception', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTISt18bad_variant_access', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTISt19bad_optional_access', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt8bad_cast', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt9bad_alloc', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTISt9exception', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 50, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt12experimental19bad_optional_accessE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110__time_getE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110__time_putE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110ctype_baseE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110istrstreamE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110money_baseE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIcLb0EEE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIcLb1EEE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIwLb0EEE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIwLb1EEE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__110ostrstreamE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__111__money_getIcEE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__111__money_getIwEE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__111__money_putIcEE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__111__money_putIwEE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__111regex_errorE', 'size': 22, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__112bad_weak_ptrE', 'size': 23, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__112codecvt_baseE', 'size': 23, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__112ctype_bynameIcEE', 'size': 26, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__112ctype_bynameIwEE', 'size': 26, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__112future_errorE', 'size': 23, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__112strstreambufE', 'size': 23, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__112system_errorE', 'size': 23, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 47, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 47, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 47, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 47, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__113messages_baseE', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114__codecvt_utf8IDiEE', 'size': 29, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114__codecvt_utf8IDsEE', 'size': 29, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114__codecvt_utf8IwEE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114__num_get_baseE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114__num_put_baseE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114__shared_countE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 48, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 43, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 43, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 42, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 42, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114collate_bynameIcEE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114collate_bynameIwEE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__114error_categoryE', 'size': 25, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDiLb0EEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDiLb1EEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDsLb0EEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDsLb1EEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IwLb0EEE', 'size': 33, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IwLb1EEE', 'size': 33, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 49, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 49, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115messages_bynameIcEE', 'size': 29, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115messages_bynameIwEE', 'size': 29, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115numpunct_bynameIcEE', 'size': 29, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115numpunct_bynameIwEE', 'size': 29, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 77, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 77, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 77, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 77, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__116__narrow_to_utf8ILm16EEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__116__narrow_to_utf8ILm32EEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__117__assoc_sub_stateE', 'size': 28, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__117__widen_from_utf8ILm16EEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__117__widen_from_utf8ILm32EEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__118__time_get_storageIcEE', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__118__time_get_storageIwEE', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__119__shared_weak_countE', 'size': 30, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__120__codecvt_utf8_utf16IwEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__120__time_get_c_storageIcEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__120__time_get_c_storageIwEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__124__libcpp_debug_exceptionE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__15ctypeIcEE', 'size': 18, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__15ctypeIwEE', 'size': 18, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__16locale5facetE', 'size': 22, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 35, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'size': 34, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17collateIcEE', 'size': 20, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17collateIwEE', 'size': 20, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 68, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 68, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 68, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 68, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18__c_nodeE', 'size': 18, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18ios_base7failureE', 'size': 26, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18ios_baseE', 'size': 18, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18messagesIcEE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18messagesIwEE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18numpunctIcEE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18numpunctIwEE', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 69, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 69, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 69, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 69, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19__num_getIcEE', 'size': 22, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19__num_getIwEE', 'size': 22, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19__num_putIcEE', 'size': 22, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19__num_putIwEE', 'size': 22, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 42, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 42, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 70, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 70, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 70, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 70, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19strstreamE', 'size': 19, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSNSt3__19time_baseE', 'size': 19, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSSt12bad_any_cast', 'size': 17, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSSt16nested_exception', 'size': 21, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSSt18bad_variant_access', 'size': 23, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTSSt19bad_optional_access', 'size': 24, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__110istrstreamE', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__110ostrstreamE', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 16, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTTNSt3__19strstreamE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVN10__cxxabiv117__class_type_infoE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVN10__cxxabiv120__si_class_type_infoE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVN10__cxxabiv121__vmi_class_type_infoE', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt12experimental19bad_optional_accessE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__110istrstreamE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIcLb0EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIcLb1EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIwLb0EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIwLb1EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__110ostrstreamE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__111regex_errorE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__112bad_weak_ptrE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__112ctype_bynameIcEE', 'size': 104, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__112ctype_bynameIwEE', 'size': 136, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__112future_errorE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__112strstreambufE', 'size': 128, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__112system_errorE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114__codecvt_utf8IDiEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114__codecvt_utf8IDsEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114__codecvt_utf8IwEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114__shared_countE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 120, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114collate_bynameIcEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114collate_bynameIwEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__114error_categoryE', 'size': 72, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 128, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 128, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115messages_bynameIcEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115messages_bynameIwEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115numpunct_bynameIcEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115numpunct_bynameIwEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 224, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 224, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 48, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 48, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__117__assoc_sub_stateE', 'size': 48, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__117__widen_from_utf8ILm16EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__117__widen_from_utf8ILm32EEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'size': 112, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__119__shared_weak_countE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__124__libcpp_debug_exceptionE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__15ctypeIcEE', 'size': 104, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__15ctypeIwEE', 'size': 136, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__16locale5facetE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17collateIcEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17collateIwEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 128, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 128, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 104, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 104, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18__c_nodeE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18ios_base7failureE', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18ios_baseE', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18messagesIcEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18messagesIwEE', 'size': 64, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18numpunctIcEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18numpunctIwEE', 'size': 80, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 168, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 168, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 48, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 48, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 56, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__19strstreamE', 'size': 120, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt11logic_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVSt12bad_any_cast', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt12length_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt12out_of_range', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt13runtime_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt14overflow_error', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt16invalid_argument', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVSt16nested_exception', 'size': 32, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVSt18bad_variant_access', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVSt19bad_optional_access', 'size': 40, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZThn16_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZThn16_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110istrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110istrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110ostrstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110ostrstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdaPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdaPvRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdaPvSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdaPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdaPvm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdaPvmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdlPv', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdlPvRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdlPvSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdlPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdlPvm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZdlPvmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_Znam', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZnamRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZnamSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZnamSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_Znwm', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZnwmRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZnwmSt11align_val_t', 'type': 'FUNC'}
+{'is_defined': True, 'name': '_ZnwmSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_allocate_exception', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_begin_catch', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_current_primary_exception', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_decrement_exception_refcount', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_end_catch', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_free_exception', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_guard_abort', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_guard_acquire', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_guard_release', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_increment_exception_refcount', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_pure_virtual', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_rethrow', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_rethrow_primary_exception', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_throw', 'type': 'FUNC'}
+{'is_defined': False, 'name': '__cxa_uncaught_exceptions', 'type': 'FUNC'}
diff --git a/utils/libcxx/sym_check/util.py b/utils/libcxx/sym_check/util.py
index c6f7e90f3..634e7684c 100644
--- a/utils/libcxx/sym_check/util.py
+++ b/utils/libcxx/sym_check/util.py
@@ -11,6 +11,7 @@ import distutils.spawn
 import sys
 import re
 import libcxx.util
+from pprint import pformat
 
 
 def read_syms_from_list(slist):
@@ -48,7 +49,8 @@ def write_syms(sym_list, out=None, names_only=False):
     if names_only:
         out_list = [sym['name'] for sym in sym_list]
     for sym in out_list:
-        out_str += '%s\n' % sym
+        # Use pformat for consistent ordering of keys.
+        out_str += pformat(sym, width=100000) + '\n'
     if out is None:
         sys.stdout.write(out_str)
     else:
-- 
GitLab


From bc415828dfa2a4f6b3805e65498a2cd58adc4852 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 10 Feb 2019 18:27:55 +0000
Subject: [PATCH 127/137] Make LIBCXX_STANDARD_VER configurable

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353649 91177308-0d34-0410-b5e6-96231b3b80d8
---
 CMakeLists.txt     | 5 +++--
 lib/CMakeLists.txt | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c6b05b61f..5567e82a2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -526,11 +526,12 @@ remove_flags("/D_DEBUG" "/MTd" "/MDd" "/MT" "/Md")
 remove_flags(-Wno-pedantic -pedantic-errors -pedantic)
 
 # Required flags ==============================================================
-set(LIBCXX_STANDARD_VER c++11 CACHE INTERNAL "internal option to change build dialect")
 if (LIBCXX_HAS_MUSL_LIBC OR LIBCXX_TARGETING_CLANG_CL)
   # musl's pthread implementations uses volatile types in their structs which is
   # not a constexpr in C++11 but is in C++14, so we use C++14 with musl.
-  set(LIBCXX_STANDARD_VER c++14 CACHE INTERNAL "internal option to change build dialect")
+  set(LIBCXX_STANDARD_VER c++14 CACHE STRING "internal option to change build dialect")
+else()
+  set(LIBCXX_STANDARD_VER c++11 CACHE STRING "internal option to change build dialect")
 endif()
 add_compile_flags_if_supported(-std=${LIBCXX_STANDARD_VER})
 add_compile_flags_if_supported("/std:${LIBCXX_STANDARD_VER}")
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 7c5096da0..e5313f159 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -328,7 +328,7 @@ if (LIBCXX_ENABLE_FILESYSTEM)
 
   set(filesystem_flags "${LIBCXX_COMPILE_FLAGS}")
   check_flag_supported(-std=c++14)
-  if (NOT MSVC AND LIBCXX_SUPPORTS_STD_EQ_CXX14_FLAG)
+  if (NOT MSVC AND LIBCXX_SUPPORTS_STD_EQ_CXX14_FLAG AND LIBCXX_STANDARD_VER STREQUAL "c++11")
     string(REPLACE "-std=c++11" "-std=c++14" filesystem_flags "${LIBCXX_COMPILE_FLAGS}")
   endif()
   set_target_properties(cxx_filesystem
-- 
GitLab


From d47c19a05535a05aea8d322ed2e4be79c1a2b749 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Sun, 10 Feb 2019 18:29:00 +0000
Subject: [PATCH 128/137] fix -Wextra-semi warnings

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353650 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/chrono | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/chrono b/include/chrono
index f7970647e..a003751ba 100644
--- a/include/chrono
+++ b/include/chrono
@@ -1749,14 +1749,14 @@ public:
     year() = default;
     explicit inline constexpr year(int __val) noexcept : __y(static_cast<short>(__val)) {}
 
-    inline constexpr year& operator++()    noexcept { ++__y; return *this; };
-    inline constexpr year  operator++(int) noexcept { year __tmp = *this; ++(*this); return __tmp; };
-    inline constexpr year& operator--()    noexcept { --__y; return *this; };
-    inline constexpr year  operator--(int) noexcept { year __tmp = *this; --(*this); return __tmp; };
+    inline constexpr year& operator++()    noexcept { ++__y; return *this; }
+    inline constexpr year  operator++(int) noexcept { year __tmp = *this; ++(*this); return __tmp; }
+    inline constexpr year& operator--()    noexcept { --__y; return *this; }
+    inline constexpr year  operator--(int) noexcept { year __tmp = *this; --(*this); return __tmp; }
            constexpr year& operator+=(const years& __dy) noexcept;
            constexpr year& operator-=(const years& __dy) noexcept;
     inline constexpr year operator+() const noexcept { return *this; }
-    inline constexpr year operator-() const noexcept { return year{-__y}; };
+    inline constexpr year operator-() const noexcept { return year{-__y}; }
 
     inline constexpr bool is_leap() const noexcept { return __y % 4 == 0 && (__y % 100 != 0 || __y % 400 == 0); }
     explicit inline constexpr operator int() const noexcept { return __y; }
-- 
GitLab


From b20da37b6bad453e58b19164a9ae999cd0798ee1 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Mon, 11 Feb 2019 08:39:14 +0000
Subject: [PATCH 129/137] Update some newly added files that mistakenly used
 the old file header to the new one.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353668 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../std/containers/associative/map/gcc_workaround.pass.cpp | 7 +++----
 .../std/containers/associative/set/gcc_workaround.pass.cpp | 7 +++----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/test/std/containers/associative/map/gcc_workaround.pass.cpp b/test/std/containers/associative/map/gcc_workaround.pass.cpp
index 9e05b66a5..6c87e51f7 100644
--- a/test/std/containers/associative/map/gcc_workaround.pass.cpp
+++ b/test/std/containers/associative/map/gcc_workaround.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/test/std/containers/associative/set/gcc_workaround.pass.cpp b/test/std/containers/associative/set/gcc_workaround.pass.cpp
index 5f4947b54..23db04405 100644
--- a/test/std/containers/associative/set/gcc_workaround.pass.cpp
+++ b/test/std/containers/associative/set/gcc_workaround.pass.cpp
@@ -1,9 +1,8 @@
 //===----------------------------------------------------------------------===//
 //
-//                     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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-- 
GitLab


From c882476dfaed7b2db84bf4f3845b632838c1fa92 Mon Sep 17 00:00:00 2001
From: Chandler Carruth <chandlerc@gmail.com>
Date: Mon, 11 Feb 2019 08:39:23 +0000
Subject: [PATCH 130/137] The new file header didn't get carried over when
 these files were "moved" somehow, update them to use it.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353669 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/docker/scripts/build_gcc_version.sh  | 7 +++----
 utils/docker/scripts/build_llvm_version.sh | 7 +++----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/utils/docker/scripts/build_gcc_version.sh b/utils/docker/scripts/build_gcc_version.sh
index f569d7e18..68aa4c67e 100755
--- a/utils/docker/scripts/build_gcc_version.sh
+++ b/utils/docker/scripts/build_gcc_version.sh
@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 #===- libcxx/utils/docker/scripts/build-gcc.sh ----------------------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===-----------------------------------------------------------------------===//
 
diff --git a/utils/docker/scripts/build_llvm_version.sh b/utils/docker/scripts/build_llvm_version.sh
index eb093c426..613a7babd 100755
--- a/utils/docker/scripts/build_llvm_version.sh
+++ b/utils/docker/scripts/build_llvm_version.sh
@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 #===- libcxx/utils/docker/scripts/build_install_llvm_version_default.sh -----------------------===//
 #
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===-------------------------------------------------------------------------------------------===//
 
-- 
GitLab


From fc1ec361d39c403915c3c3c2c74468451fade20f Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Mon, 11 Feb 2019 08:48:47 +0000
Subject: [PATCH 131/137] [libcxx] Preserve order, avoid duplicates when
 merging static archives

glob can return files in arbitrary order which breaks deterministic
builds. Rather, use `ar t` to list the files in each archive and
preserve the original order. Using `ar q` results in duplicate entries
in the archive, instead use `ar r` to avoid duplicates.

Differential Revision: https://reviews.llvm.org/D58024

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353671 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/merge_archives.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/utils/merge_archives.py b/utils/merge_archives.py
index a307494d8..e57afab20 100755
--- a/utils/merge_archives.py
+++ b/utils/merge_archives.py
@@ -78,6 +78,7 @@ def execute_command_verbose(cmd, cwd=None, verbose=False):
         sys.stderr.write('%s\n' % report)
         if exitCode != 0:
             exit_with_cleanups(exitCode)
+    return out
 
 def main():
     parser = ArgumentParser(
@@ -119,15 +120,15 @@ def main():
     global temp_directory_root
     temp_directory_root = tempfile.mkdtemp('.libcxx.merge.archives')
 
+    files = []
     for arc in archives:
-        execute_command_verbose([ar_exe, 'x', arc], cwd=temp_directory_root,
-                                verbose=args.verbose)
-
-    files = glob.glob(os.path.join(temp_directory_root, '*.o*'))
-    if not files:
-        print_and_exit('Failed to glob for %s' % temp_directory_root)
-    cmd = [ar_exe, 'qcs', args.output] + files
-    execute_command_verbose(cmd, cwd=temp_directory_root, verbose=args.verbose)
+        execute_command_verbose([ar_exe, 'x', arc],
+                                cwd=temp_directory_root, verbose=args.verbose)
+        out = execute_command_verbose([ar_exe, 't', arc])
+        files.extend(out.splitlines())
+
+    execute_command_verbose([ar_exe, 'rcsD', args.output] + files,
+                            cwd=temp_directory_root, verbose=args.verbose)
 
 
 if __name__ == '__main__':
-- 
GitLab


From ecc2c089fd997a787b3e2817765ca966384b7281 Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Mon, 11 Feb 2019 23:47:19 +0000
Subject: [PATCH 132/137] Add fenv.h header

Summary:
Some implementations of fenv.h use macros to define the functions they provide. This can cause problems when `std::fegetround()` is spelled in source.

This patch adds a `fenv.h` header to libc++ for the sole purpose of turning those macros into real functions.

Reviewers: rsmith, mclow.lists, ldionne

Reviewed By: rsmith

Subscribers: mgorny, christof, libcxx-commits

Differential Revision: https://reviews.llvm.org/D57729

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353767 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/CMakeLists.txt                        |   1 +
 include/fenv.h                                | 204 ++++++++++++++++++
 include/module.modulemap                      |   5 +-
 test/libcxx/depr/depr.c.headers/fenv.pass.cpp |  19 ++
 test/libcxx/double_include.sh.cpp             |   1 +
 test/libcxx/include_as_c.sh.cpp               |   1 +
 test/std/depr/depr.c.headers/fenv_h.pass.cpp  |  22 +-
 7 files changed, 241 insertions(+), 12 deletions(-)
 create mode 100644 include/fenv.h
 create mode 100644 test/libcxx/depr/depr.c.headers/fenv.pass.cpp

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 73f7cfc4d..3bd09b329 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -95,6 +95,7 @@ set(files
   ext/__hash
   ext/hash_map
   ext/hash_set
+  fenv.h
   filesystem
   float.h
   forward_list
diff --git a/include/fenv.h b/include/fenv.h
new file mode 100644
index 000000000..6c979ac5a
--- /dev/null
+++ b/include/fenv.h
@@ -0,0 +1,204 @@
+// -*- C++ -*-
+//===---------------------------- math.h ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_FENV_H
+#define _LIBCPP_FENV_H
+
+
+/*
+    fenv.h synopsis
+
+This entire header is C99 / C++0X
+
+Macros:
+
+    FE_DIVBYZERO
+    FE_INEXACT
+    FE_INVALID
+    FE_OVERFLOW
+    FE_UNDERFLOW
+    FE_ALL_EXCEPT
+    FE_DOWNWARD
+    FE_TONEAREST
+    FE_TOWARDZERO
+    FE_UPWARD
+    FE_DFL_ENV
+
+Types:
+
+    fenv_t
+    fexcept_t
+
+int feclearexcept(int excepts);
+int fegetexceptflag(fexcept_t* flagp, int excepts);
+int feraiseexcept(int excepts);
+int fesetexceptflag(const fexcept_t* flagp, int excepts);
+int fetestexcept(int excepts);
+int fegetround();
+int fesetround(int round);
+int fegetenv(fenv_t* envp);
+int feholdexcept(fenv_t* envp);
+int fesetenv(const fenv_t* envp);
+int feupdateenv(const fenv_t* envp);
+
+
+*/
+
+#include <__config>
+#include_next <fenv.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#ifdef __cplusplus
+
+extern "C++" {
+
+#ifdef feclearexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_feclearexcept(int __excepts) {
+  return feclearexcept(__excepts);
+}
+#undef feclearexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int feclearexcept(int __excepts) {
+  return ::__libcpp_feclearexcept(__excepts);
+}
+#endif // defined(feclearexcept)
+
+#ifdef fegetexceptflag
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_fegetexceptflag(fexcept_t* __out_ptr, int __excepts) {
+  return fegetexceptflag(__out_ptr, __excepts);
+}
+#undef fegetexceptflag
+_LIBCPP_INLINE_VISIBILITY
+inline int fegetexceptflag(fexcept_t *__out_ptr, int __excepts) {
+  return ::__libcpp_fegetexceptflag(__out_ptr, __excepts);
+}
+#endif // defined(fegetexceptflag)
+
+
+#ifdef feraiseexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_feraiseexcept(int __excepts) {
+  return feraiseexcept(__excepts);
+}
+#undef feraiseexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int feraiseexcept(int __excepts) {
+  return ::__libcpp_feraiseexcept(__excepts);
+}
+#endif // defined(feraiseexcept)
+
+
+#ifdef fesetexceptflag
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_fesetexceptflag(const fexcept_t* __out_ptr, int __excepts) {
+  return fesetexceptflag(__out_ptr, __excepts);
+}
+#undef fesetexceptflag
+_LIBCPP_INLINE_VISIBILITY
+inline int fesetexceptflag(const fexcept_t *__out_ptr, int __excepts) {
+  return ::__libcpp_fesetexceptflag(__out_ptr, __excepts);
+}
+#endif // defined(fesetexceptflag)
+
+
+#ifdef fetestexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_fetestexcept(int __excepts) {
+  return fetestexcept(__excepts);
+}
+#undef fetestexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int fetestexcept(int __excepts) {
+  return ::__libcpp_fetestexcept(__excepts);
+}
+#endif // defined(fetestexcept)
+
+#ifdef fegetround
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_fegetround() {
+  return fegetround();
+}
+#undef fegetround
+_LIBCPP_INLINE_VISIBILITY
+inline int fegetround() {
+  return ::__libcpp_fegetround();
+}
+#endif // defined(fegetround)
+
+#ifdef fesetround
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_fesetround(int __round) {
+  return fesetround(__round);
+}
+#undef fesetround
+_LIBCPP_INLINE_VISIBILITY
+inline int fesetround(int __round) {
+  return ::__libcpp_fesetround(__round);
+}
+#endif // defined(fesetround)
+
+#ifdef fegetenv
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_fegetenv(fenv_t* __envp) {
+  return fegetenv(__envp);
+}
+#undef fegetenv
+_LIBCPP_INLINE_VISIBILITY
+inline int fegetenv(fenv_t* __envp) {
+  return ::__libcpp_fegetenv(__envp);
+}
+#endif // defined(fegetenv)
+
+#ifdef feholdexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_feholdexcept(fenv_t* __envp) {
+  return feholdexcept(__envp);
+}
+#undef feholdexcept
+_LIBCPP_INLINE_VISIBILITY
+inline int feholdexcept(fenv_t* __envp) {
+  return ::__libcpp_feholdexcept(__envp);
+}
+#endif // defined(feholdexcept)
+
+
+#ifdef fesetenv
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_fesetenv(const fenv_t* __envp) {
+  return fesetenv(__envp);
+}
+#undef fesetenv
+_LIBCPP_INLINE_VISIBILITY
+inline int fesetenv(const fenv_t* __envp) {
+  return ::__libcpp_fesetenv(__envp);
+}
+#endif // defined(fesetenv)
+
+#ifdef feupdateenv
+_LIBCPP_INLINE_VISIBILITY
+inline int __libcpp_feupdateenv(const fenv_t* __envp) {
+  return feupdateenv(__envp);
+}
+#undef feupdateenv
+_LIBCPP_INLINE_VISIBILITY
+inline int feupdateenv(const fenv_t* __envp) {
+  return ::__libcpp_feupdateenv(__envp);
+}
+#endif // defined(feupdateenv)
+
+} // extern "C++"
+
+#endif // defined(__cplusplus)
+
+#endif // _LIBCPP_FENV_H
diff --git a/include/module.modulemap b/include/module.modulemap
index 6d88f5211..bbfe90ed5 100644
--- a/include/module.modulemap
+++ b/include/module.modulemap
@@ -24,7 +24,10 @@ module std [system] {
       header "errno.h"
       export *
     }
-    // <fenv.h> provided by C library.
+    module fenv_h {
+      header "fenv.h"
+      export *
+    }
     // <float.h> provided by compiler or C library.
     module inttypes_h {
       header "inttypes.h"
diff --git a/test/libcxx/depr/depr.c.headers/fenv.pass.cpp b/test/libcxx/depr/depr.c.headers/fenv.pass.cpp
new file mode 100644
index 000000000..9cc7063e8
--- /dev/null
+++ b/test/libcxx/depr/depr.c.headers/fenv.pass.cpp
@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <fenv.h>
+
+#include <fenv.h>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}
diff --git a/test/libcxx/double_include.sh.cpp b/test/libcxx/double_include.sh.cpp
index a167b0a58..2ee444af5 100644
--- a/test/libcxx/double_include.sh.cpp
+++ b/test/libcxx/double_include.sh.cpp
@@ -63,6 +63,7 @@
 #include <deque>
 #include <errno.h>
 #include <exception>
+#include <fenv.h>
 #include <filesystem>
 #include <float.h>
 #include <forward_list>
diff --git a/test/libcxx/include_as_c.sh.cpp b/test/libcxx/include_as_c.sh.cpp
index c056f61ae..67d5e14b3 100644
--- a/test/libcxx/include_as_c.sh.cpp
+++ b/test/libcxx/include_as_c.sh.cpp
@@ -17,6 +17,7 @@
 #include <complex.h>
 #include <ctype.h>
 #include <errno.h>
+#include <fenv.h>
 #include <float.h>
 #include <inttypes.h>
 #include <limits.h>
diff --git a/test/std/depr/depr.c.headers/fenv_h.pass.cpp b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
index 3a6f63c3f..6b38f4e6c 100644
--- a/test/std/depr/depr.c.headers/fenv_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/fenv_h.pass.cpp
@@ -61,17 +61,17 @@ int main(int, char**)
 {
     fenv_t fenv = {};
     fexcept_t fex = 0;
-    static_assert((std::is_same<decltype(feclearexcept(0)), int>::value), "");
-    static_assert((std::is_same<decltype(fegetexceptflag(&fex, 0)), int>::value), "");
-    static_assert((std::is_same<decltype(feraiseexcept(0)), int>::value), "");
-    static_assert((std::is_same<decltype(fesetexceptflag(&fex, 0)), int>::value), "");
-    static_assert((std::is_same<decltype(fetestexcept(0)), int>::value), "");
-    static_assert((std::is_same<decltype(fegetround()), int>::value), "");
-    static_assert((std::is_same<decltype(fesetround(0)), int>::value), "");
-    static_assert((std::is_same<decltype(fegetenv(&fenv)), int>::value), "");
-    static_assert((std::is_same<decltype(feholdexcept(&fenv)), int>::value), "");
-    static_assert((std::is_same<decltype(fesetenv(&fenv)), int>::value), "");
-    static_assert((std::is_same<decltype(feupdateenv(&fenv)), int>::value), "");
+    static_assert((std::is_same<decltype(::feclearexcept(0)), int>::value), "");
+    static_assert((std::is_same<decltype(::fegetexceptflag(&fex, 0)), int>::value), "");
+    static_assert((std::is_same<decltype(::feraiseexcept(0)), int>::value), "");
+    static_assert((std::is_same<decltype(::fesetexceptflag(&fex, 0)), int>::value), "");
+    static_assert((std::is_same<decltype(::fetestexcept(0)), int>::value), "");
+    static_assert((std::is_same<decltype(::fegetround()), int>::value), "");
+    static_assert((std::is_same<decltype(::fesetround(0)), int>::value), "");
+    static_assert((std::is_same<decltype(::fegetenv(&fenv)), int>::value), "");
+    static_assert((std::is_same<decltype(::feholdexcept(&fenv)), int>::value), "");
+    static_assert((std::is_same<decltype(::fesetenv(&fenv)), int>::value), "");
+    static_assert((std::is_same<decltype(::feupdateenv(&fenv)), int>::value), "");
 
   return 0;
 }
-- 
GitLab


From 199f01c55f4ecd0bee0fd044c16cd1457befc90f Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Tue, 12 Feb 2019 00:00:43 +0000
Subject: [PATCH 133/137] Make the sym_diff utilities more useful.

In particular when working with static libraries and libstdc++.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353772 91177308-0d34-0410-b5e6-96231b3b80d8
---
 utils/libcxx/sym_check/extract.py | 28 ++++++++++++++++++----------
 utils/libcxx/sym_check/util.py    | 14 ++++++++------
 utils/sym_extract.py              | 15 ++++++++++++++-
 3 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/utils/libcxx/sym_check/extract.py b/utils/libcxx/sym_check/extract.py
index 1012c6b11..6089ec234 100644
--- a/utils/libcxx/sym_check/extract.py
+++ b/utils/libcxx/sym_check/extract.py
@@ -10,6 +10,7 @@
 extract - A set of function that extract symbol lists from shared libraries.
 """
 import distutils.spawn
+import os.path
 import sys
 import re
 
@@ -30,7 +31,7 @@ class NMExtractor(object):
         """
         return distutils.spawn.find_executable('nm')
 
-    def __init__(self):
+    def __init__(self, static_lib):
         """
         Initialize the nm executable and flags that will be used to extract
         symbols from shared libraries.
@@ -40,8 +41,10 @@ class NMExtractor(object):
             # ERROR no NM found
             print("ERROR: Could not find nm")
             sys.exit(1)
+        self.static_lib = static_lib
         self.flags = ['-P', '-g']
 
+
     def extract(self, lib):
         """
         Extract symbols from a library and return the results as a dict of
@@ -53,7 +56,7 @@ class NMExtractor(object):
             raise RuntimeError('Failed to run %s on %s' % (self.nm_exe, lib))
         fmt_syms = (self._extract_sym(l)
                     for l in out.splitlines() if l.strip())
-            # Cast symbol to string.
+        # Cast symbol to string.
         final_syms = (repr(s) for s in fmt_syms if self._want_sym(s))
         # Make unique and sort strings.
         tmp_list = list(sorted(set(final_syms)))
@@ -116,7 +119,7 @@ class ReadElfExtractor(object):
         """
         return distutils.spawn.find_executable('readelf')
 
-    def __init__(self):
+    def __init__(self, static_lib):
         """
         Initialize the readelf executable and flags that will be used to
         extract symbols from shared libraries.
@@ -126,6 +129,8 @@ class ReadElfExtractor(object):
             # ERROR no NM found
             print("ERROR: Could not find readelf")
             sys.exit(1)
+        # TODO: Support readelf for reading symbols from archives
+        assert not static_lib and "RealElf does not yet support static libs"
         self.flags = ['--wide', '--symbols']
 
     def extract(self, lib):
@@ -180,14 +185,17 @@ class ReadElfExtractor(object):
         return lines[start:end]
 
 
-def extract_symbols(lib_file):
+def extract_symbols(lib_file, static_lib=None):
     """
-    Extract and return a list of symbols extracted from a dynamic library.
-    The symbols are extracted using NM. They are then filtered and formated.
-    Finally they symbols are made unique.
+    Extract and return a list of symbols extracted from a static or dynamic
+    library. The symbols are extracted using NM or readelf. They are then
+    filtered and formated. Finally they symbols are made unique.
     """
-    if ReadElfExtractor.find_tool():
-        extractor = ReadElfExtractor()
+    if static_lib is None:
+        _, ext = os.path.splitext(lib_file)
+        static_lib = True if ext in ['.a'] else False
+    if ReadElfExtractor.find_tool() and not static_lib:
+        extractor = ReadElfExtractor(static_lib=static_lib)
     else:
-        extractor = NMExtractor()
+        extractor = NMExtractor(static_lib=static_lib)
     return extractor.extract(lib_file)
diff --git a/utils/libcxx/sym_check/util.py b/utils/libcxx/sym_check/util.py
index 634e7684c..0ebde9034 100644
--- a/utils/libcxx/sym_check/util.py
+++ b/utils/libcxx/sym_check/util.py
@@ -39,15 +39,17 @@ def read_blacklist(filename):
     return lines
 
 
-def write_syms(sym_list, out=None, names_only=False):
+def write_syms(sym_list, out=None, names_only=False, filter=None):
     """
     Write a list of symbols to the file named by out.
     """
     out_str = ''
     out_list = sym_list
     out_list.sort(key=lambda x: x['name'])
+    if filter is not None:
+        out_list = filter(out_list)
     if names_only:
-        out_list = [sym['name'] for sym in sym_list]
+        out_list = [sym['name'] for sym in out_list]
     for sym in out_list:
         # Use pformat for consistent ordering of keys.
         out_str += pformat(sym, width=100000) + '\n'
@@ -242,10 +244,11 @@ cxxabi_symbols = [
     '_ZTSy'
 ]
 
-def is_stdlib_symbol_name(name):
+def is_stdlib_symbol_name(name, sym):
     name = adjust_mangled_name(name)
     if re.search("@GLIBC|@GCC", name):
-        return False
+        # Only when symbol is defined do we consider it ours
+        return sym['is_defined']
     if re.search('(St[0-9])|(__cxa)|(__cxxabi)', name):
         return True
     if name in new_delete_std_symbols:
@@ -261,8 +264,7 @@ def filter_stdlib_symbols(syms):
     other_symbols = []
     for s in syms:
         canon_name = adjust_mangled_name(s['name'])
-        if not is_stdlib_symbol_name(canon_name):
-            assert not s['is_defined'] and "found defined non-std symbol"
+        if not is_stdlib_symbol_name(canon_name, s):
             other_symbols += [s]
         else:
             stdlib_symbols += [s]
diff --git a/utils/sym_extract.py b/utils/sym_extract.py
index 156e8830e..987c207c1 100755
--- a/utils/sym_extract.py
+++ b/utils/sym_extract.py
@@ -27,14 +27,27 @@ def main():
     parser.add_argument('--only-stdlib-symbols', dest='only_stdlib',
                         help="Filter all symbols not related to the stdlib",
                         action='store_true', default=False)
+    parser.add_argument('--defined-only', dest='defined_only',
+                        help="Filter all symbols that are not defined",
+                        action='store_true', default=False)
+    parser.add_argument('--undefined-only', dest='undefined_only',
+                        help="Filter all symbols that are defined",
+                        action='store_true', default=False)
+
     args = parser.parse_args()
+    assert not (args.undefined_only and args.defined_only)
     if args.output is not None:
         print('Extracting symbols from %s to %s.'
               % (args.library, args.output))
     syms = extract.extract_symbols(args.library)
     if args.only_stdlib:
         syms, other_syms = util.filter_stdlib_symbols(syms)
-    util.write_syms(syms, out=args.output, names_only=args.names_only)
+    filter = lambda x: x
+    if args.defined_only:
+      filter = lambda l: list([x for x in l if x['is_defined']])
+    if args.undefined_only:
+      filter = lambda l: list([x for x in l if not x['is_defined']])
+    util.write_syms(syms, out=args.output, names_only=args.names_only, filter=filter)
 
 
 if __name__ == '__main__':
-- 
GitLab


From e88eb48b17e9c0d8cb5d1b1390a325db3c338ded Mon Sep 17 00:00:00 2001
From: Eric Fiselier <eric@efcs.ca>
Date: Tue, 12 Feb 2019 00:05:14 +0000
Subject: [PATCH 134/137] Don't declare fenv.h functions when they're a macro.

libc still provides function declarations, and these declarations
conflict with libc++'s

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353774 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/fenv.h | 111 +++++--------------------------------------------
 1 file changed, 11 insertions(+), 100 deletions(-)

diff --git a/include/fenv.h b/include/fenv.h
index 6c979ac5a..7cede4b34 100644
--- a/include/fenv.h
+++ b/include/fenv.h
@@ -62,140 +62,51 @@ int feupdateenv(const fenv_t* envp);
 extern "C++" {
 
 #ifdef feclearexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_feclearexcept(int __excepts) {
-  return feclearexcept(__excepts);
-}
 #undef feclearexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int feclearexcept(int __excepts) {
-  return ::__libcpp_feclearexcept(__excepts);
-}
-#endif // defined(feclearexcept)
+#endif
 
 #ifdef fegetexceptflag
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_fegetexceptflag(fexcept_t* __out_ptr, int __excepts) {
-  return fegetexceptflag(__out_ptr, __excepts);
-}
 #undef fegetexceptflag
-_LIBCPP_INLINE_VISIBILITY
-inline int fegetexceptflag(fexcept_t *__out_ptr, int __excepts) {
-  return ::__libcpp_fegetexceptflag(__out_ptr, __excepts);
-}
-#endif // defined(fegetexceptflag)
+#endif
 
 
 #ifdef feraiseexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_feraiseexcept(int __excepts) {
-  return feraiseexcept(__excepts);
-}
 #undef feraiseexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int feraiseexcept(int __excepts) {
-  return ::__libcpp_feraiseexcept(__excepts);
-}
-#endif // defined(feraiseexcept)
-
+#endif
 
 #ifdef fesetexceptflag
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_fesetexceptflag(const fexcept_t* __out_ptr, int __excepts) {
-  return fesetexceptflag(__out_ptr, __excepts);
-}
 #undef fesetexceptflag
-_LIBCPP_INLINE_VISIBILITY
-inline int fesetexceptflag(const fexcept_t *__out_ptr, int __excepts) {
-  return ::__libcpp_fesetexceptflag(__out_ptr, __excepts);
-}
-#endif // defined(fesetexceptflag)
+#endif
 
 
 #ifdef fetestexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_fetestexcept(int __excepts) {
-  return fetestexcept(__excepts);
-}
 #undef fetestexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int fetestexcept(int __excepts) {
-  return ::__libcpp_fetestexcept(__excepts);
-}
-#endif // defined(fetestexcept)
+#endif
 
 #ifdef fegetround
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_fegetround() {
-  return fegetround();
-}
 #undef fegetround
-_LIBCPP_INLINE_VISIBILITY
-inline int fegetround() {
-  return ::__libcpp_fegetround();
-}
-#endif // defined(fegetround)
+#endif
 
 #ifdef fesetround
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_fesetround(int __round) {
-  return fesetround(__round);
-}
 #undef fesetround
-_LIBCPP_INLINE_VISIBILITY
-inline int fesetround(int __round) {
-  return ::__libcpp_fesetround(__round);
-}
-#endif // defined(fesetround)
+#endif
 
 #ifdef fegetenv
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_fegetenv(fenv_t* __envp) {
-  return fegetenv(__envp);
-}
 #undef fegetenv
-_LIBCPP_INLINE_VISIBILITY
-inline int fegetenv(fenv_t* __envp) {
-  return ::__libcpp_fegetenv(__envp);
-}
-#endif // defined(fegetenv)
+#endif
 
 #ifdef feholdexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_feholdexcept(fenv_t* __envp) {
-  return feholdexcept(__envp);
-}
 #undef feholdexcept
-_LIBCPP_INLINE_VISIBILITY
-inline int feholdexcept(fenv_t* __envp) {
-  return ::__libcpp_feholdexcept(__envp);
-}
-#endif // defined(feholdexcept)
+#endif
 
 
 #ifdef fesetenv
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_fesetenv(const fenv_t* __envp) {
-  return fesetenv(__envp);
-}
 #undef fesetenv
-_LIBCPP_INLINE_VISIBILITY
-inline int fesetenv(const fenv_t* __envp) {
-  return ::__libcpp_fesetenv(__envp);
-}
-#endif // defined(fesetenv)
+#endif
 
 #ifdef feupdateenv
-_LIBCPP_INLINE_VISIBILITY
-inline int __libcpp_feupdateenv(const fenv_t* __envp) {
-  return feupdateenv(__envp);
-}
 #undef feupdateenv
-_LIBCPP_INLINE_VISIBILITY
-inline int feupdateenv(const fenv_t* __envp) {
-  return ::__libcpp_feupdateenv(__envp);
-}
-#endif // defined(feupdateenv)
+#endif
 
 } // extern "C++"
 
-- 
GitLab


From f759756c126dcf3f24f7636cf071a4db0f574186 Mon Sep 17 00:00:00 2001
From: Petr Hosek <phosek@chromium.org>
Date: Tue, 12 Feb 2019 01:35:29 +0000
Subject: [PATCH 135/137] [CMake] Avoid passing -rtlib=compiler-rt when using
 compiler-rt

We build libc++ and libc++abi with -nodefaultlibs, so -rtlib=compiler-rt
has no effect and results in an 'argument unused during compilation'
warning which breaks the build when using -Werror. We can therefore drop
-rtlib=compiler-rt without any functional change; note that the actual
compiler-rt linking is handled by HandleCompilerRT.

Differential Revision: https://reviews.llvm.org/D58084

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353786 91177308-0d34-0410-b5e6-96231b3b80d8
---
 CMakeLists.txt | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5567e82a2..0be001503 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -485,10 +485,6 @@ endif()
 # Configure compiler.
 include(config-ix)
 
-if (LIBCXX_USE_COMPILER_RT)
-  list(APPEND LIBCXX_LINK_FLAGS "-rtlib=compiler-rt")
-endif()
-
 # Configure coverage options.
 if (LIBCXX_GENERATE_COVERAGE)
   include(CodeCoverage)
-- 
GitLab


From af15bb4cdfc82d030d5826b0ecdc915652cacb80 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Tue, 12 Feb 2019 16:06:02 +0000
Subject: [PATCH 136/137] [libc++] Avoid UB in the no-exceptions mode in a few
 places

Summary:
A few places in the library seem to behave unexpectedly when the library
is compiled or used with exceptions disabled. For example, not throwing
an exception when a pointer is NULL can lead us to dereference the pointer
later on, which is UB. This patch fixes such occurences.

It's hard to tell whether there are other places where the no-exceptions
mode misbehaves like this, because the replacement for throwing an
exception does not always seem to be abort()ing, but at least this
patch will improve the situation somewhat.

See http://lists.llvm.org/pipermail/libcxx-dev/2019-January/000172.html

Reviewers: mclow.lists, EricWF

Subscribers: christof, jkorous, dexonsmith, libcxx-commits

Differential Revision: https://reviews.llvm.org/D57761

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353850 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/ios                                   | 10 +++++
 include/map                                   |  8 +---
 include/unordered_map                         |  8 +---
 src/hash.cpp                                  | 12 +-----
 src/ios.cpp                                   | 21 +++-------
 src/locale.cpp                                | 16 ++------
 .../associative/map/at.abort.pass.cpp         | 34 +++++++++++++++
 .../associative/map/at.const.abort.pass.cpp   | 34 +++++++++++++++
 .../unord/unord.map/at.abort.pass.cpp         | 31 ++++++++++++++
 .../unord/unord.map/at.const.abort.pass.cpp   | 31 ++++++++++++++
 .../ios/iostate.flags/clear.abort.pass.cpp    | 41 +++++++++++++++++++
 .../locales/locale.abort.pass.cpp             | 34 +++++++++++++++
 .../locales/locale.category.abort.pass.cpp    | 34 +++++++++++++++
 .../locales/use_facet.abort.pass.cpp          | 37 +++++++++++++++++
 14 files changed, 301 insertions(+), 50 deletions(-)
 create mode 100644 test/libcxx/containers/associative/map/at.abort.pass.cpp
 create mode 100644 test/libcxx/containers/associative/map/at.const.abort.pass.cpp
 create mode 100644 test/libcxx/containers/unord/unord.map/at.abort.pass.cpp
 create mode 100644 test/libcxx/containers/unord/unord.map/at.const.abort.pass.cpp
 create mode 100644 test/libcxx/input.output/iostreams.base/ios/iostate.flags/clear.abort.pass.cpp
 create mode 100644 test/libcxx/localization/locales/locale.abort.pass.cpp
 create mode 100644 test/libcxx/localization/locales/locale.category.abort.pass.cpp
 create mode 100644 test/libcxx/localization/locales/use_facet.abort.pass.cpp

diff --git a/include/ios b/include/ios
index 963363963..96e84eb38 100644
--- a/include/ios
+++ b/include/ios
@@ -425,6 +425,16 @@ public:
     virtual ~failure() throw();
 };
 
+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
+void __throw_failure(char const* __msg) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    throw ios_base::failure(__msg);
+#else
+    ((void)__msg);
+    _VSTD::abort();
+#endif
+}
+
 class _LIBCPP_TYPE_VIS ios_base::Init
 {
 public:
diff --git a/include/map b/include/map
index 47f5c678b..e21dd5a84 100644
--- a/include/map
+++ b/include/map
@@ -1535,10 +1535,8 @@ map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k)
 {
     __parent_pointer __parent;
     __node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__child == nullptr)
-        throw out_of_range("map::at:  key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __throw_out_of_range("map::at:  key not found");
     return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
 }
 
@@ -1548,10 +1546,8 @@ map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
 {
     __parent_pointer __parent;
     __node_base_pointer __child = __tree_.__find_equal(__parent, __k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__child == nullptr)
-        throw out_of_range("map::at:  key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __throw_out_of_range("map::at:  key not found");
     return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
 }
 
diff --git a/include/unordered_map b/include/unordered_map
index 87278b07d..7ae9805d8 100644
--- a/include/unordered_map
+++ b/include/unordered_map
@@ -1602,10 +1602,8 @@ _Tp&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k)
 {
     iterator __i = find(__k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__i == end())
-        throw out_of_range("unordered_map::at: key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __throw_out_of_range("unordered_map::at: key not found");
     return __i->second;
 }
 
@@ -1614,10 +1612,8 @@ const _Tp&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const
 {
     const_iterator __i = find(__k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__i == end())
-        throw out_of_range("unordered_map::at: key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __throw_out_of_range("unordered_map::at: key not found");
     return __i->second;
 }
 
diff --git a/src/hash.cpp b/src/hash.cpp
index 1631b91ac..89bb736c8 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -153,12 +153,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if<_Sz == 4, void>::type
 __check_for_overflow(size_t N)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (N > 0xFFFFFFFB)
-        throw overflow_error("__next_prime overflow");
-#else
-    (void)N;
-#endif
+        __throw_overflow_error("__next_prime overflow");
 }
 
 template <size_t _Sz = sizeof(size_t)>
@@ -166,12 +162,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if<_Sz == 8, void>::type
 __check_for_overflow(size_t N)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (N > 0xFFFFFFFFFFFFFFC5ull)
-        throw overflow_error("__next_prime overflow");
-#else
-    (void)N;
-#endif
+        __throw_overflow_error("__next_prime overflow");
 }
 
 size_t
diff --git a/src/ios.cpp b/src/ios.cpp
index fdff2e8fe..2dc84be82 100644
--- a/src/ios.cpp
+++ b/src/ios.cpp
@@ -266,10 +266,9 @@ ios_base::clear(iostate state)
         __rdstate_ = state;
     else
         __rdstate_ = state | badbit;
-#ifndef _LIBCPP_NO_EXCEPTIONS
+
     if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
-        throw failure("ios_base::clear");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __throw_failure("ios_base::clear");
 }
 
 // init
@@ -309,35 +308,27 @@ ios_base::copyfmt(const ios_base& rhs)
     {
         size_t newesize = sizeof(event_callback) * rhs.__event_size_;
         new_callbacks.reset(static_cast<event_callback*>(malloc(newesize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_callbacks)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __throw_bad_alloc();
 
         size_t newisize = sizeof(int) * rhs.__event_size_;
         new_ints.reset(static_cast<int *>(malloc(newisize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_ints)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __throw_bad_alloc();
     }
     if (__iarray_cap_ < rhs.__iarray_size_)
     {
         size_t newsize = sizeof(long) * rhs.__iarray_size_;
         new_longs.reset(static_cast<long*>(malloc(newsize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_longs)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __throw_bad_alloc();
     }
     if (__parray_cap_ < rhs.__parray_size_)
     {
         size_t newsize = sizeof(void*) * rhs.__parray_size_;
         new_pointers.reset(static_cast<void**>(malloc(newsize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_pointers)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __throw_bad_alloc();
     }
     // Got everything we need.  Copy everything but __rdstate_, __rdbuf_ and __exceptions_
     __fmtflags_ = rhs.__fmtflags_;
diff --git a/src/locale.cpp b/src/locale.cpp
index 18edad73f..00eb574ec 100644
--- a/src/locale.cpp
+++ b/src/locale.cpp
@@ -468,10 +468,8 @@ locale::__imp::install(facet* f, long id)
 const locale::facet*
 locale::__imp::use_facet(long id) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (!has_facet(id))
-        throw bad_cast();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __throw_bad_cast();
     return facets_[static_cast<size_t>(id)];
 }
 
@@ -537,12 +535,8 @@ locale::operator=(const locale& other)  _NOEXCEPT
 }
 
 locale::locale(const char* name)
-#ifndef _LIBCPP_NO_EXCEPTIONS
     : __locale_(name ? new __imp(name)
-                     : throw runtime_error("locale constructed with null"))
-#else  // _LIBCPP_NO_EXCEPTIONS
-    : __locale_(new __imp(name))
-#endif
+                     : (__throw_runtime_error("locale constructed with null"), (__imp*)0))
 {
     __locale_->__add_shared();
 }
@@ -554,12 +548,8 @@ locale::locale(const string& name)
 }
 
 locale::locale(const locale& other, const char* name, category c)
-#ifndef _LIBCPP_NO_EXCEPTIONS
     : __locale_(name ? new __imp(*other.__locale_, name, c)
-                     : throw runtime_error("locale constructed with null"))
-#else  // _LIBCPP_NO_EXCEPTIONS
-    : __locale_(new __imp(*other.__locale_, name, c))
-#endif
+                     : (__throw_runtime_error("locale constructed with null"), (__imp*)0))
 {
     __locale_->__add_shared();
 }
diff --git a/test/libcxx/containers/associative/map/at.abort.pass.cpp b/test/libcxx/containers/associative/map/at.abort.pass.cpp
new file mode 100644
index 000000000..d34f48f4d
--- /dev/null
+++ b/test/libcxx/containers/associative/map/at.abort.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class map
+
+// mapped_type& at(const key_type& k);
+
+// Make sure we abort() when exceptions are disabled and we fetch a key that
+// is not in the map.
+
+// REQUIRES: libcpp-no-exceptions
+
+#include <csignal>
+#include <cstdlib>
+#include <map>
+
+
+void exit_success(int) {
+    std::_Exit(EXIT_SUCCESS);
+}
+
+int main(int, char**) {
+    std::signal(SIGABRT, exit_success);
+    std::map<int, int> map;
+    map.at(1);
+    return EXIT_FAILURE;
+}
diff --git a/test/libcxx/containers/associative/map/at.const.abort.pass.cpp b/test/libcxx/containers/associative/map/at.const.abort.pass.cpp
new file mode 100644
index 000000000..705ada869
--- /dev/null
+++ b/test/libcxx/containers/associative/map/at.const.abort.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class map
+
+// const mapped_type& at(const key_type& k) const;
+
+// Make sure we abort() when exceptions are disabled and we fetch a key that
+// is not in the map.
+
+// REQUIRES: libcpp-no-exceptions
+
+#include <csignal>
+#include <cstdlib>
+#include <map>
+
+
+void exit_success(int) {
+    std::_Exit(EXIT_SUCCESS);
+}
+
+int main(int, char**) {
+    std::signal(SIGABRT, exit_success);
+    std::map<int, int> const map;
+    map.at(1);
+    return EXIT_FAILURE;
+}
diff --git a/test/libcxx/containers/unord/unord.map/at.abort.pass.cpp b/test/libcxx/containers/unord/unord.map/at.abort.pass.cpp
new file mode 100644
index 000000000..b65af169b
--- /dev/null
+++ b/test/libcxx/containers/unord/unord.map/at.abort.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_map
+
+// mapped_type& at(const key_type& k);
+
+// Make sure we abort() when exceptions are disabled and we fetch a key that
+// is not in the map.
+
+// REQUIRES: libcpp-no-exceptions
+// UNSUPPORTED: c++98, c++03
+
+#include <csignal>
+#include <cstdlib>
+#include <unordered_map>
+
+
+int main(int, char**) {
+    std::signal(SIGABRT, [](int) { std::_Exit(EXIT_SUCCESS); });
+    std::unordered_map<int, int> map;
+    map.at(1);
+    return EXIT_FAILURE;
+}
diff --git a/test/libcxx/containers/unord/unord.map/at.const.abort.pass.cpp b/test/libcxx/containers/unord/unord.map/at.const.abort.pass.cpp
new file mode 100644
index 000000000..af2a2cd76
--- /dev/null
+++ b/test/libcxx/containers/unord/unord.map/at.const.abort.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_map
+
+// const mapped_type& at(const key_type& k) const;
+
+// Make sure we abort() when exceptions are disabled and we fetch a key that
+// is not in the map.
+
+// REQUIRES: libcpp-no-exceptions
+// UNSUPPORTED: c++98, c++03
+
+#include <csignal>
+#include <cstdlib>
+#include <unordered_map>
+
+
+int main(int, char**) {
+    std::signal(SIGABRT, [](int) { std::_Exit(EXIT_SUCCESS); });
+    std::unordered_map<int, int> const map;
+    map.at(1);
+    return EXIT_FAILURE;
+}
diff --git a/test/libcxx/input.output/iostreams.base/ios/iostate.flags/clear.abort.pass.cpp b/test/libcxx/input.output/iostreams.base/ios/iostate.flags/clear.abort.pass.cpp
new file mode 100644
index 000000000..e6dc1c981
--- /dev/null
+++ b/test/libcxx/input.output/iostreams.base/ios/iostate.flags/clear.abort.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <ios>
+
+// template <class charT, class traits> class basic_ios
+
+// void clear(iostate state);
+
+// Make sure that we abort() when exceptions are disabled and the exception
+// flag is set for the iostate we pass to clear().
+
+// REQUIRES: libcpp-no-exceptions
+
+#include <csignal>
+#include <cstdlib>
+#include <ios>
+#include <streambuf>
+
+
+void exit_success(int) {
+    std::_Exit(EXIT_SUCCESS);
+}
+
+struct testbuf : public std::streambuf {};
+
+int main(int, char**) {
+    std::signal(SIGABRT, exit_success);
+
+    testbuf buf;
+    std::ios ios(&buf);
+    ios.exceptions(std::ios::badbit);
+    ios.clear(std::ios::badbit);
+
+    return EXIT_FAILURE;
+}
diff --git a/test/libcxx/localization/locales/locale.abort.pass.cpp b/test/libcxx/localization/locales/locale.abort.pass.cpp
new file mode 100644
index 000000000..5817ebdfd
--- /dev/null
+++ b/test/libcxx/localization/locales/locale.abort.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <locale>
+
+// class locale;
+
+// explicit locale( const char* std_name );
+
+// REQUIRES: libcpp-no-exceptions
+
+// Make sure we abort() when we construct a locale with a null name and
+// exceptions are disabled.
+
+#include <csignal>
+#include <cstdlib>
+#include <locale>
+
+
+void exit_success(int) {
+    std::_Exit(EXIT_SUCCESS);
+}
+
+int main(int, char**) {
+    std::signal(SIGABRT, exit_success);
+    std::locale loc(NULL);
+    (void)loc;
+    return EXIT_FAILURE;
+}
diff --git a/test/libcxx/localization/locales/locale.category.abort.pass.cpp b/test/libcxx/localization/locales/locale.category.abort.pass.cpp
new file mode 100644
index 000000000..cf50415a2
--- /dev/null
+++ b/test/libcxx/localization/locales/locale.category.abort.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <locale>
+
+// class locale;
+
+// locale(const locale& other, const char* std_name, category cat);
+
+// REQUIRES: libcpp-no-exceptions
+
+// Make sure we abort() when we construct a locale with a null name and
+// exceptions are disabled.
+
+#include <csignal>
+#include <cstdlib>
+#include <locale>
+
+
+void exit_success(int) {
+    std::_Exit(EXIT_SUCCESS);
+}
+
+int main(int, char**) {
+    std::signal(SIGABRT, exit_success);
+    std::locale loc(std::locale(), NULL, std::locale::ctype);
+    (void)loc;
+    return EXIT_FAILURE;
+}
diff --git a/test/libcxx/localization/locales/use_facet.abort.pass.cpp b/test/libcxx/localization/locales/use_facet.abort.pass.cpp
new file mode 100644
index 000000000..64700eab9
--- /dev/null
+++ b/test/libcxx/localization/locales/use_facet.abort.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <locale>
+
+// template <class Facet> const Facet& use_facet(const locale& loc);
+
+// REQUIRES: libcpp-no-exceptions
+
+// Make sure we abort() when we pass a facet not associated to the locale to
+// use_facet() and exceptions are disabled.
+
+#include <csignal>
+#include <cstdlib>
+#include <locale>
+
+
+struct my_facet : public std::locale::facet {
+    static std::locale::id id;
+};
+
+std::locale::id my_facet::id;
+
+void exit_success(int) {
+    std::_Exit(EXIT_SUCCESS);
+}
+
+int main(int, char**) {
+    std::signal(SIGABRT, exit_success);
+    std::use_facet<my_facet>(std::locale());
+    return EXIT_FAILURE;
+}
-- 
GitLab


From 712d476de34e15f9fec9841c39b02b2993ff28ae Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne@apple.com>
Date: Wed, 13 Feb 2019 16:43:44 +0000
Subject: [PATCH 137/137] [libcxx] Do not assume the number of elements in a
 moved-from associative container

Reviewed as https://reviews.llvm.org/D57903.
Thanks to Andrey Maksimov for the patch.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@353955 91177308-0d34-0410-b5e6-96231b3b80d8
---
 .../associative/map/map.cons/move_alloc.pass.cpp         | 9 ++++++---
 .../multimap/multimap.cons/move_alloc.pass.cpp           | 9 ++++++---
 .../multiset/multiset.cons/move_alloc.pass.cpp           | 9 ++++++---
 .../associative/set/set.cons/move_alloc.pass.cpp         | 9 ++++++---
 4 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
index aa87e9ff0..cc22a4c34 100644
--- a/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
@@ -178,15 +178,18 @@ int main(int, char**)
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == num+6);
+            assert(Counter_base::gConstructed >= (int)(num+6));
+            assert(Counter_base::gConstructed <= (int)(num+6+m1.size()));
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == num+6);
+            assert(Counter_base::gConstructed >= (int)(num+6));
+            assert(Counter_base::gConstructed <= (int)(num+6+m1.size()+m2.size()));
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == num+3);
+            assert(Counter_base::gConstructed >= (int)(num+3));
+            assert(Counter_base::gConstructed <= (int)(num+3+m1.size()+m2.size()));
         }
         assert(Counter_base::gConstructed == 0);
     }
diff --git a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
index 712afbeaa..4505cd216 100644
--- a/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
@@ -178,15 +178,18 @@ int main(int, char**)
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed >= (int)(3*num));
+            assert(Counter_base::gConstructed <= (int)(4*num));
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed >= (int)(3*num));
+            assert(Counter_base::gConstructed <= (int)(5*num));
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == 2*num);
+            assert(Counter_base::gConstructed >= (int)(2*num));
+            assert(Counter_base::gConstructed <= (int)(4*num));
         }
         assert(Counter_base::gConstructed == 0);
     }
diff --git a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
index 1abe5b928..3727c143d 100644
--- a/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
@@ -172,15 +172,18 @@ int main(int, char**)
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed >= (int)(3*num));
+            assert(Counter_base::gConstructed <= (int)(4*num));
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed >= (int)(3*num));
+            assert(Counter_base::gConstructed <= (int)(5*num));
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == 2*num);
+            assert(Counter_base::gConstructed >= (int)(2*num));
+            assert(Counter_base::gConstructed <= (int)(4*num));
         }
         assert(Counter_base::gConstructed == 0);
     }
diff --git a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
index db7933e92..63ec29689 100644
--- a/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
@@ -172,15 +172,18 @@ int main(int, char**)
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == 6+num);
+            assert(Counter_base::gConstructed >= (int)(6+num));
+            assert(Counter_base::gConstructed <= (int)(m1.size()+6+num));
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == 6+num);
+            assert(Counter_base::gConstructed >= (int)(6+num));
+            assert(Counter_base::gConstructed <= (int)(m1.size()+m2.size()+6+num));
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == 3+num);
+            assert(Counter_base::gConstructed >= (int)(3+num));
+            assert(Counter_base::gConstructed <= (int)(m1.size()+m2.size()+3+num));
         }
         assert(Counter_base::gConstructed == 0);
     }
-- 
GitLab